CS422 Computer Architecture A Quantitative Approach Solution For 5th Edition

Machine Translated by Google
Bab 1 Solusi 2
Bab 2 Solusi 6
Bab 3 Solusi 13
Bab 4 Solusi 33
Bab 5 Solusi 44
Bab 6 Solusi 50
Lampiran A Solusi 63
Solusi Lampiran B 83
Solusi Lampiran C 92
Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

Solusi untuk Studi Kasus dan Latihan

2 ÿ Solusi untuk Studi Kasus dan Latihan
Bab 1 Solusi
Studi Kasus 1: Biaya Pembuatan Chip
4–
1.1 A. Menghasilkan = ÿ ÿ 04,00--3--,-8-9---×--1--- = 0,36
+------------
ÿ
B. Itu dibuat dalam teknologi yang lebih besar, yang merupakan pabrik yang lebih tua. Seiring bertambahnya usia tanaman,
proses mereka disetel, dan tingkat kecacatan menurun.
ÿ×( 2 ÿ × 30 –
) 30 2ÿ
1.2 sebuah. Meninggal per wafer =---------------------------------------------------------------- 471 54,4 416 =–= kuadrat 2
1.5 1,5 ( ) ×
0,30 1,5 × ÿ 4–
Menghasilkan = ÿ 1 ------------------------+ = 0,65
ÿ 4.0 ÿ
Untung = 416 × 0,65 × $20 = $5408
2
ÿ × ( ) 30 2ÿ
ÿ × 30 –
B. Meninggal per wafer =----------------------------------------------------------------283 42,1 240 =–= ( kuadrat
2.5 2 2,5 ) ×
0,30 2,5 × 1 + 4–
= ÿ ------------------------- = 0,50
Menghasilkan
ÿ
ÿ 4,0 ÿ
Untung = 240 × 0,50 × $25 = $3000
C. Chip Woods d. Woods
chips: 50.000/416 = 120,2 wafer yang dibutuhkan Markon chips: 25.000/240
= 104.2 wafers Oleh karena itu, pembagian yang paling menguntungkan adalah
120 Woods wafer, 30 Markon wafer.
4–
1.3 sebuah. Cacat – Inti tunggal gratis = ÿ ÿ 04,,705--1--,-9-9---2--ÿ-×---1-- = 0,28
+----------------
ÿ
Tidak ada cacat = 0,282 = 0,08 Satu
cacat = 0,28 × 0,72 × 2 = 0,40 Tidak lebih dari satu
cacat = 0,08 + 0,40 = 0,48
Ukuran wafer
B. $20 =
dpw lama 0,28×
$20 × 0,28 = Ukuran wafer/dpw lama
Ukuran wafer $20 0,28 ×

= = = $23,33
X
1/2 dpw lama × × 0,48 1/2 0,48 ×

Bab 1 Solusi ÿ 3
Studi Kasus 2: Konsumsi Daya di Sistem Komputer

1.4 sebuah. 0,80x = 66 + 2 × 2,3 + 7,9; x = 99
B. 0,6 × 4 W + 0,4 × 7,9 = 5,56
C. Selesaikan empat persamaan berikut:

seek7200 = 0,75 × seek5400
seek7200 + idle7200 = 100
seek5400 + idle5400 = 100
seek7200 × 7,9 + idle7200 × 4 = seek5400 × 7 + idle5400 × 2,9
menganggur7200 = 29,8%
14KW
1,5 sebuah. -------------------------------------------------- ---------
183 =
( 66 W 2,3 W 7,9 W+) +
14KW
B. -------------------------------------------------- -------------------
166 =
( 66 W 2,+3 W 2 + 7,W9 × )
C. 200 W × 11 = 2200 W 2200/

(76,2) = 28 rak Hanya
diperlukan 1 pintu pendingin.
1.6 sebuah. IBM x346 dapat mengambil lebih sedikit ruang, yang akan menghemat uang di real estat. Rak mungkin
lebih baik ditata. Bisa juga jauh lebih murah. Selain itu, jika kami menjalankan aplikasi yang tidak
sesuai dengan karakteristik tolok ukur tersebut, IBM x346 mungkin lebih
cepat. Terakhir, tidak ada angka reliabilitas yang ditampilkan. Meskipun kami tidak tahu bahwa IBM
x346 lebih baik di salah satu area ini, kami juga tidak tahu itu lebih buruk.
1.7 sebuah. (1 – 8) + 0,8/2 = 0,2 + 0,4 = 0,6

2
Kekuatan baru × ( F × 0,60)
B.----------------------- = (V×
-------------------------------------------------- -------- == 0,62316
Tenaga tua V2 × F
.75
C. 1 =----------------------------------
; x = 50%
( )+1x –ÿx2
2
Kekuatan baru ( V × 0,75 ) × ( F × 0,60)
D. -------------------------- = == × 0 , 6 0 , 3 3
---------- ---------- ------ --- ---------- ------ --- -- ---- 0,752
Tenaga tua
8 V2 × F
Latihan
1.8 sebuah. (1,35)10 = kira-kira 20 b. 3200 ×
(1,4)12 = sekitar 181.420 c. 3200 × (1,01)12 = kira-
kira 3605 d. Kepadatan daya, yaitu daya yang
dikonsumsi di area yang semakin kecil, telah menciptakan terlalu banyak panas untuk dihamburkan oleh heat
sink. Ini telah membatasi aktivitas transistor pada chip. Alih-alih meningkatkan kecepatan jam, pabrikan
menempatkan banyak inti pada chip.
e. Apa pun dalam kisaran 15–25% akan menjadi kesimpulan yang masuk akal berdasarkan penurunan
tingkat sepanjang sejarah. Namun, seperti yang ditunjukkan oleh penghentian tiba-tiba dalam
clock rate, bahkan penurunannya tidak selalu mengikuti prediksi.
1.9 sebuah. 50%
B. Energi = ½ beban × V2 . Mengubah frekuensi tidak memengaruhi daya hanya energi. Jadi energi
baru adalah ½ beban × ( ½ V)2 , menguranginya menjadi sekitar ¼ energi lama energi.
1.10 sebuah. 60%
B. 0,4 + 0,6 × 0,2 = 0,58, yang mengurangi energi menjadi 58% dari aslinya
energi.
C. Daya baru/Daya lama = ½ Kapasitansi × (Tegangan × 0,8)2 × (Frekuensi × 0,6)/½

Kapasitansi × Tegangan × Frekuensi = 0,82 × 0,6 = 0,256 dari daya asli.
D. 0,4 + 0 ,3 × 2 = 0,46, yang mengurangi energi menjadi 46% dari energi semula. 1.11 sebuah. 109/100
= 107b . 107/107 +
24 = 1
C. [butuh solusi]
1.12 sebuah. 35/10000 × 3333 = 11,67 hari
B. Ada beberapa jawaban yang benar. Salah satunya adalah, dengan sistem saat ini, satu komputer gagal
kira-kira setiap 5 menit. 5 menit sepertinya bukan waktu yang cukup untuk mengisolasi komputer,
menukarnya, dan mengembalikan komputer ke jalur semula. Namun, 10 menit jauh lebih mungkin.
Bagaimanapun, itu akan sangat memperpanjang jumlah waktu sebelum 1/3 komputer gagal sekaligus.
Karena biaya downtime sangat besar, bisa memperpanjang ini sangat berharga. C. $90.000 = (x + x +
x + 2x)/4 $360.000 = 5x $72.000
= x kuartal ke-4 =
$144.000/jam
1.13 sebuah. Itanium, karena memiliki waktu eksekusi keseluruhan yang lebih rendah.
B. Opteron: 0,6 × 0,92 + 0,2 × 1,03 + 0,2 × 0,65 = 0,888

C. 1/0,888 = 1,126
1.14 sebuah. Lihat Gambar
S.1. B. 2 = 1/((1 – x) + x/10)

5/9 = x = 0,56 atau 56% C.
0,056/0,5 = 0,11 atau 11%
D. Percepatan maksimum = 1/(1/10) = 10 5 =

1/((1 – x) + x/10) 8/9 = x
= 0,89 atau 89%

Machine Translated by
Bab 1 Solusi ÿ 5
12
10
0
0 10 20 30 40 50 60 70 80 90 100
Vektorisasi persen
Gambar S.1 Plot persamaan: y = 100/((100 – x) + x/10).
e. Percepatan saat ini: 1/(0,3 + 0,7/10) = 1/0,37 = 2,7 Sasaran

percepatan: 5,4 = 1/((1 – x) + x /10) = x = 0,91
Ini berarti persentase vektorisasi harus 91%
1.15 sebuah. waktu eksekusi lama = 0,5 baru + 0,5 × 10 baru = 5,5 baru
B. Dalam kode aslinya, bagian yang tidak ditingkatkan waktunya sama dengan bagian yang ditingkatkan
dipercepat 10, oleh karena itu:
(1 – x) = x/
10 10 – 10x
= x 10 =
11x 10/11 = x = 0.91
1.16 sebuah. 1/(0,8 + 0,20/2) = 1,11
B. 1/(0,7 + 0,20/2 + 0,10 × 3/2) = 1,05
C. operasi fp: 0,1/0,95 = 10,5%, tembolok: 0,15/0,95 = 15,8% 1.17

sebuah. 1/(0,6 + 0,4/2) = 1,25
B. 1/(0,01 + 0,99/2) = 1,98

C. 1/(0,2 + 0,8 × 0,6 + 0,8 × 0,4/2) = 1/(,2 + ,48 + ,16) = 1,19
D. 1/(0,8 + 0,2 × 0,01 + 0,2 × 0,99/2) = 1/(0,8 + 0,002 + 0,099) = 1,11
1.18 sebuah. 1/(.2 + .8/N)

B. 1/(.2 + 8 × 0,005 + 0,8/8) = 2,94
C. 1/(.2 + 3 × 0,005 + 0,8/8) = 3,17
D. 1/(.2 + logN × 0,005 + 0,8/N) e. d/

dN(1/((1 – P) + logN × 0,005 + P/N)) = 0

Bab 2 Solusi
Studi Kasus 1: Mengoptimalkan Kinerja Cache via
Teknik Lanjutan
2.1 A. Setiap elemen adalah 8B. Karena cacheline 64B memiliki 8 elemen, dan setiap akses kolom akan
menghasilkan pengambilan baris baru untuk matriks non-ideal, kita membutuhkan minimal 8x8 (64
elemen) untuk setiap matriks. Oleh karena itu, ukuran cache minimum
adalah 128 × 8B = 1KB.
B. Versi yang diblokir hanya perlu mengambil setiap elemen masukan dan keluaran satu kali. Versi yang
tidak diblokir akan kehilangan satu cache untuk setiap 64B/8B = 8 elemen baris. Setiap kolom
membutuhkan penyimpanan 64Bx256, atau 16KB. Dengan demikian, elemen kolom akan diganti
dalam cache sebelum dapat digunakan kembali. Oleh karena itu, versi
yang tidak diblokir akan memiliki 9 kesalahan (1 baris dan 8 kolom) untuk setiap 2 kesalahan dalam versi
yang diblokir.
C. untuk (i = 0; i < 256; i=i+B) {

untuk (j = 0; j < 256; j=j+B) { untuk(m=0; m<B;
m++) { untuk(n=0; n<B;
n++) { output[j+n][ i+m] =
masukan[i+m][j+n];
D. asosiatif himpunan 2 arah. Dalam cache yang dipetakan langsung, blok dapat dialokasikan
sehingga mereka memetakan ke wilayah yang tumpang tindih di cache.
e. Anda harus dapat menentukan ukuran cache level-1 dengan memvariasikan ukuran blok. Rasio
kecepatan program yang diblokir dan tidak diblokir untuk larik yang tidak sesuai dengan cache
dibandingkan dengan blok yang sesuai adalah fungsi dari ukuran blok cache, apakah mesin memiliki
masalah out-of-order, dan lebar pita yang disediakan oleh cache level-2. Anda mungkin memiliki
ketidaksesuaian jika mesin Anda memiliki cache level-1 yang dapat ditulisi dan buffer tulis menjadi
pembatas kinerja.
2.2 Karena versi yang tidak diblokir terlalu besar untuk muat di dalam cache, pemrosesan delapan elemen 8B
memerlukan pengambilan satu blok cache baris 64B dan 8 blok cache kolom. Karena setiap iterasi
membutuhkan 2 siklus tanpa kesalahan, pengambilan awal dapat dimulai setiap 2 siklus, dan jumlah
pengambilan awal per iterasi lebih dari satu, sistem memori akan sepenuhnya jenuh dengan pengambilan
awal. Karena latensi prefetch adalah 16 siklus, dan satu siklus akan dimulai setiap 2 siklus, 16/2 = 8 akan
keluar sekaligus.
2.3 Buka latihan langsung, tidak ada solusi tetap.

Bab 2 Solusi ÿ 7
Studi Kasus 2: Menyatukan Semuanya: Sangat Paralel

Sistem Memori
2.4 sebuah. Cache tingkat kedua adalah 1MB dan memiliki ukuran blok 128B.
B. Hukuman miss dari cache tingkat kedua kira-kira 105ns. C. Cache tingkat kedua adalah
asosiatif set 8 arah. D. Memori utama adalah 512MB.
e. Berjalan melalui halaman dengan
langkah 16B membutuhkan 946ns per referensi. Dengan 250 referensi seperti itu per halaman, hasilnya
sekitar 240 md per halaman. 2.5 sebuah. Petunjuk: Hal ini terlihat pada grafik
di atas sebagai sedikit peningkatan dalam L2 miss service time untuk set data besar, dan 4KB untuk grafik di
atas.
B. Petunjuk: Ambil langkah independen berdasarkan ukuran halaman dan cari peningkatan latensi yang
tidak disebabkan oleh ukuran cache. Ini mungkin sulit dilihat jika jumlah memori yang dipetakan
oleh TLB hampir sama dengan ukuran level cache.
C. Petunjuk: Hal ini terlihat pada grafik di atas sebagai sedikit peningkatan pada miss service L2 waktu
untuk kumpulan data besar, dan 15ns pada grafik di atas.
D. Petunjuk: Ambil langkah independen yang merupakan kelipatan dari ukuran halaman untuk melihat
apakah TLB sepenuhnya asosiatif atau set-asosiatif. Ini mungkin sulit dilihat jika jumlah memori
yang dipetakan oleh TLB hampir sama dengan ukuran level cache.
2.6 sebuah. Petunjuk: Lihatlah kecepatan program yang dengan mudah masuk ke cache tingkat atas sebagai
fungsi dari jumlah utas.
B. Petunjuk: Bandingkan kinerja referensi independen sebagai fungsi dari

penempatan mereka dalam memori.
2.7 Buka latihan langsung, tidak ada solusi pasti.
Latihan
2.8 sebuah. Waktu akses cache yang dipetakan langsung adalah 0,86ns, sedangkan cache 2 arah dan 4 arah
masing-masing adalah 1,12ns dan 1,37ns. Ini membuat waktu akses relatif 1,12/.86
= 1,30 atau 30% lebih banyak untuk 2 arah dan 1,37/0,86 = 1,59 atau 59% lebih banyak untuk 4
arah.
B. Waktu akses cache 16KB adalah 1,27ns, sedangkan 32KB dan 64KB masing-masing adalah 1,35ns
dan 1,37ns. Ini membuat waktu akses relatif 1,35/1,27 = 1,06 atau 6% lebih besar untuk 32KB dan
1,37/1,27 = 1,078 atau 8% lebih besar untuk 64KB.
C. Rata-rata waktu akses = hit% × waktu hit + miss% × miss penalti, miss% = miss per instruksi/
referensi per instruksi = 2.2% (DM), 1.2% (2-way), 0.33% (4-way), .09 % (8 arah).
Waktu akses yang dipetakan langsung = .86ns @ .5ns waktu siklus = 2 siklus
Asosiatif himpunan 2 arah = 1.12ns @ .5ns waktu siklus = 3 siklus

Asosiatif himpunan 4 arah = 1,37ns @ ,83ns waktu siklus = 2 siklus Asosiatif

himpunan 8 arah = 2,03ns @ ,79ns waktu siklus = 3 siklus Hukuman meleset =
(10/.5) = 20 siklus untuk DM dan 2 arah ; 10/.83 = 13 siklus untuk 4 arah; 10/.79 = 13 siklus untuk 8 arah.
Dipetakan langsung – (1 – .022) × 2 + .022 × (20) = 2.39 6 siklus => 2.396 × .5 = 1.2ns 2 arah – (1 –
.012) × 3 + .012 × (20) = 3. 2 siklus => 3.2 × .5 = 1.6ns 4 arah – (1 – .0033) × 2 + .0033 ×
(13) = 2.036 siklus => 2.06 × .83 = 1.69ns 8 arah – ( 1 – .0009) × 3 + .0009 × 13 = 3 siklus => 3 × .79 =
2.37ns Cache yang dipetakan langsung adalah yang terbaik.
2.9 sebuah. Waktu akses memori rata-rata dari cache saat ini (4 arah 64KB) adalah 1,69ns.
64KB waktu akses cache yang dipetakan langsung = .86ns @ .5 ns waktu siklus = 2 siklus Cache yang
diprediksi jalan memiliki waktu siklus dan waktu akses yang mirip dengan cache yang dipetakan langsung dan
tingkat kesalahan yang mirip dengan cache 4 arah.
AMAT dari cara prediksi cache memiliki tiga komponen: miss, hit dengan prediksi cara yang benar, dan hit
dengan prediksi cara salah prediksi: 0.0033 × (20) + (0.80 × 2 + (1 – 0.80) × 3) × (1 – 0,0033) = 2,26 siklus =
1,13ns b. Waktu siklus cache 4 arah 64KB adalah 0,83ns, sedangkan cache
yang dipetakan langsung 64KB dapat diakses dalam 0,5ns. Ini memberikan akses cache 0,83/0,5 = 1,66 atau 66%
lebih cepat.
C. Dengan penalti salah prediksi 1 siklus, AMAT adalah 1,13ns (sesuai bagian a), tetapi dengan penalti salah prediksi
15 siklus, AMAT menjadi: 0,0033 × 20 + (0,80 × 2 + (1 – 0,80) × 15) × (1 – 0,0033) = 4,65 siklus atau 2,3ns.
D. Akses serial adalah 2.4ns/1.59ns = 1.509 atau 51% lebih lambat.
2.10 sebuah. Waktu aksesnya adalah 1,12ns, sedangkan waktu siklusnya adalah 0,51ns, yang bisa jadi berpotensi
pipelined sehalus 1.12/.51 = 2.2 pipestages.
B. Desain jaringan pipa (tidak termasuk latch area dan daya) memiliki luas 1,19 mm2 dan energi per akses 0,16nJ.
Cache yang dibelokkan memiliki luas 1,36 mm2 dan energi per akses 0,13nJ. Desain yang dibelokkan
menggunakan area yang sedikit lebih banyak karena memiliki lebih banyak ampli indera dan sirkuit lain untuk
mendukung kedua bank, sedangkan desain yang menggunakan pipa membakar sedikit lebih banyak daya
karena susunan memori yang aktif lebih besar daripada di casing yang dibelokkan.
2.11 sebuah. Dengan kata kritis terlebih dahulu, miss service akan membutuhkan 120 siklus. Tanpa kata kritis terlebih dahulu,
akan membutuhkan 120 siklus untuk 16B pertama dan 16 siklus untuk masing-masing 3 blok 16B berikutnya,
atau 120 + (3 × 16) = 168 siklus. B. Itu tergantung pada kontribusi ke
Waktu Akses Memori Rata-Rata (AMAT) dari cache level-1 dan level-2 yang hilang dan persentase pengurangan
waktu layanan yang terlewatkan yang diberikan oleh kata kritis pertama dan restart awal. Jika persentase
pengurangan waktu miss service yang diberikan oleh critical word first dan early restart kira-kira sama untuk
miss service level-1 dan level-2, maka jika miss level-1 berkontribusi lebih banyak pada AMAT, kata critical
first kemungkinan akan menjadi lebih penting untuk miss level-1.

Bab 2 Solusi ÿ 9
2.12 sebuah. 16B, untuk mencocokkan jalur penulisan cache data level 2.
B. Asumsikan menggabungkan entri buffer tulis selebar 16B. Karena setiap toko dapat menulis 8B,
entri buffer tulis yang digabungkan akan terisi dalam 2 siklus. Cache level-2 akan membutuhkan
4 siklus untuk menulis setiap entri. Buffer tulis non-penggabungan akan membutuhkan 4 siklus
untuk menulis hasil 8B dari setiap penyimpanan. Ini berarti buffer tulis penggabungan akan 2
kali lebih cepat.
C. Dengan cache pemblokiran, keberadaan kesalahan secara efektif membekukan kemajuan yang
dibuat oleh mesin, jadi apakah ada kesalahan atau tidak, tidak mengubah jumlah entri buffer
tulis yang diperlukan. Dengan cache non-pemblokiran,
penulisan dapat diproses dari buffer tulis selama kesalahan, yang mungkin berarti lebih sedikit
entri yang diperlukan.
2.13 sebuah. DRAM 2GB dengan paritas atau ECC secara efektif memiliki 9 bit byte, dan akan
membutuhkan 18 DRAM 1Gb. Untuk membuat 72 bit keluaran, masing-masing harus
menghasilkan 72/18 =
4 bit. B. Panjang semburan 4 membaca 32B.

C. Bandwidth DDR-667 DIMM adalah 667 × 8 = 5336 MB/s.
Bandwidth DDR-533 DIMM adalah 533 × 8 = 4264 MB/s.
2.14 sebuah. Ini mirip dengan skenario yang diberikan pada gambar, tetapi tRCD dan CL sama- sama 5.
Selain itu, kami mengambil dua kali data pada gambar. Oleh karena itu diperlukan 5 + 5 + 4
× 2 = 18 siklus jam 333MHz, atau 18 × (1/333MHz) = 54.0ns.
B. Pembacaan ke bank terbuka memerlukan 5 + 4 = 9 siklus jam 333MHz, atau 27.0ns. Dalam
kasus aktivasi bank, ini adalah 14 siklus, atau 42.0ns. Termasuk 20ns untuk pemrosesan yang
salah pada chip, ini menjadikan keduanya 42 + 20 = 61ns dan 27.0
+ 20 = 47ns. Termasuk waktu pada chip, aktivasi bank membutuhkan waktu 61/47 = 1,30
atau 30% lebih lama.
2.15 Biaya kedua sistem adalah $2 × 130 + $800 = $1060 dengan DDR2-667 DIMM dan 2 × $100
+ $800 = $1000 dengan DDR2-533 DIMM. Latensi untuk melayani kesalahan level-2 adalah 14 ×
(1/333MHz) = 42ns 80% dari waktu dan 9 × (1/333 MHz) = 27ns 20% dari waktu dengan DDR2-667
DIMM.
Ini adalah 12 × (1/266MHz) = 45ns (80% dari waktu) dan 8 × (1/266MHz) = 30ns (20% dari
waktu) dengan DDR-533 DIMM. CPI yang ditambahkan oleh kesalahan level-2 dalam kasus
DDR2-667 adalah 0,00333 × 42 × .8 + 0,00333 × 27 × .2 = 0,130 sehingga
menghasilkan total 1,5 + 0,130 = 1,63. Sementara itu CPI ditambah dengan misses level-2 untuk
DDR-533 adalah 0.00333 × 45 × .8 + 0.00333 × 30 × .2 = 0.140 memberikan total 1.5
+ 0.140 = 1.64. Jadi penurunannya hanya 1,64/1,63 = 1,006, atau 0,6%, sedangkan biayanya
$1060/$1000 = 1,06 atau 6,0% lebih besar. Biaya/kinerja sistem DDR2-667 adalah 1,63 × 1060 =
1728 sedangkan biaya/kinerja sistem DDR2-533 adalah 1,64 × 1000
= 1640, sehingga sistem DDR2-533 adalah nilai yang lebih baik.
2.16 Inti akan mengeksekusi 8 inti × 3GHz/2.0CPI = 12 miliar instruksi per detik. Ini akan
menghasilkan 12 × 0,00667 = 80 juta kesalahan level-2 per detik.
Dengan panjang rentetan 8, ini akan menjadi 80 × 32B = 2560MB/detik. Jika memori

bandwidth kadang-kadang 2X ini, itu akan menjadi 5120MB/detik. Dari Gambar 2.14, ini hampir tidak berada dalam
bandwidth yang disediakan oleh DIMM DDR2-667, jadi hanya satu saluran memori yang cukup.
2.17 sebuah. Sistem yang dibangun dari DRAM 1Gb akan memiliki bank dua kali lebih banyak daripada sistem yang dibangun
dari DRAM 2Gb. Dengan demikian sistem berbasis 1Gb harus memberikan kinerja yang lebih tinggi karena dapat
membuka lebih banyak bank secara bersamaan.
B. Daya yang diperlukan untuk menggerakkan jalur keluaran sama dalam kedua kasus, tetapi sistem yang dibangun
dengan DRAM x4 akan memerlukan pengaktifan bank pada 18 DRAM, dibandingkan hanya 9 DRAM untuk bagian
x8. Ukuran halaman yang diaktifkan pada setiap bagian x4 dan x8 adalah sama, dan membutuhkan energi aktivasi
yang kira-kira sama. Jadi karena ada lebih sedikit DRAM yang diaktifkan dalam opsi desain x8, itu akan memiliki
daya yang lebih rendah.
2.18 a. Dengan kebijakan 1, Delay

Precharge Trp = 5 × (1/333 MHz) = 15ns Delay aktivasi Trcd = 5
× (1/333 MHz) = 15ns Kolom pilih delay Tcas = 4 × (1/333 MHz) = 12ns
Waktu akses saat ada hit buffer baris
r (Tcas Tddr ) +
Th =
100
Waktu akses ketika ada miss
= ( ) 100 r – ( Trp Trcd Tcas Tddr +++ )

Tm 100
Dengan kebijakan 2,
Waktu akses = Trcd + Tcas + Tddr
Jika A adalah jumlah total akses, titik tip-off akan terjadi ketika waktu akses bersih dengan kebijakan 1 sama dengan
total waktu akses dengan kebijakan 2. Yaitu,
R--
-- (-- Tcas+ Tddr ) A
(
100 r – 100
+ ---1--0-0 ------+T+rp Trcd Tcas Tddr ) +
= (Trcd + Tcas + Tddr)A
ÿ= r
100 Trp ×
Trp Trcd +
r = 100 (×15)/ (15 + 15) = 50%
Jika r kurang dari 50%, maka kita harus menutup halaman secara proaktif untuk mendapatkan performa terbaik, jika
tidak, kita dapat membiarkan halaman tetap terbuka.
B. Manfaat utama dari menutup halaman adalah untuk menyembunyikan Trp penundaan pra-pengisian dari jalur kritis.
Jika aksesnya back to back, maka ini tidak mungkin. Batasan baru ini tidak akan memengaruhi kebijakan 1.
Bab 2 Solusi ÿ 11
Persamaan baru untuk kebijakan 2,
Waktu akses saat kita dapat menyembunyikan penundaan prabayar = Trcd + Tcas + Tddr
Waktu akses saat penundaan precharge berada di jalur kritis = Trcd + Tcas + Trp + Tddr
Persamaan 1 sekarang akan menjadi,
R 100 – r
--------(Tcas Tddr + ) A + ----------------( Trp Trcd Tcas Tddr +++ A )
100
= 0,9 × ( Trcd Tcas Tddr ) A + 0,1 × ( Trcd Tcas++T+rp Tddr ) ++
ÿ r 90 = × ÿÿ Trp
Trp Trcd + ÿÿ
r = 90 × 15/30 = 45%
C. Untuk tingkat hit buffer baris apa pun, kebijakan 2 memerlukan tambahan r × (2 + 4) nJ per akses. Jika r =
50%, maka kebijakan 2 membutuhkan energi tambahan sebesar 3nJ.
2.19 Hibernasi akan berguna ketika energi statis yang disimpan dalam DRAM setidaknya sama dengan energi yang
dibutuhkan untuk menyalin dari DRAM ke Flash dan kemudian kembali ke DRAM.
Energi dinamis DRAM untuk membaca/menulis dapat diabaikan dibandingkan dengan Flash dan dapat
diabaikan.
6–
8 1×0×9××2 2,56 10
Waktu =
64 1,6 ×
= 400 detik
Faktor 2 pada persamaan di atas adalah karena untuk hibernasi dan bangun, baik Flash maupun DRAM harus
dibaca dan ditulis satu kali.
2.20 sebuah. Ya. Lingkungan aplikasi dan produksi dapat dijalankan pada VM yang dihosting pada
mesin pengembangan.
B. Ya. Aplikasi dapat diterapkan ulang di lingkungan yang sama di atas VM yang berjalan di perangkat keras
yang berbeda. Hal ini biasa disebut kelangsungan usaha.
C. Tidak. Bergantung pada dukungan dalam arsitektur, virtualisasi I/O dapat menambahkan sig
overhead kinerja yang signifikan atau sangat signifikan.
D. Ya. Aplikasi yang berjalan pada mesin virtual berbeda diisolasi dari
satu sama lain.
e. Ya. Lihat “Mesin virtual yang dapat divirtualisasikan yang memungkinkan pemeliharaan umum, node tunggal,
online,” David Lowell, Yasushi Saito, dan Eileen Samberg, dalam Proceedings of the 11th ASPLOS, 2004,
halaman 211–223.
2.21 sebuah. Program yang melakukan banyak perhitungan tetapi memiliki set kerja memori kecil
dan melakukan sedikit I/O atau panggilan sistem lainnya.
B. Perlambatan di atas adalah 60% untuk 10%, jadi 20% waktu sistem akan berjalan
120% lebih lambat.
C. Median perlambatan menggunakan virtualisasi murni adalah 10.3, sedangkan untuk para virtu
alisasi median perlambatan adalah 3,76.

D. Panggilan nol dan panggilan I/O nol memiliki pelambatan terbesar. Ini tidak memiliki pekerjaan nyata
untuk melebihi overhead virtualisasi dari perubahan tingkat perlindungan, sehingga mereka memiliki
pelambatan terbesar.
2.22 Mesin virtual yang berjalan di atas mesin virtual lain harus meniru tingkat hak istimewa yang
terlambat seolah-olah mesin tersebut berjalan di host tanpa teknologi VT-x. 2.23
sebuah. Pada tanggal makalah Komputer, AMD-V menambahkan lebih banyak dukungan untuk virtualisasi
memori virtual, sehingga dapat memberikan kinerja yang lebih tinggi untuk aplikasi intensif
memori dengan footprint memori yang besar.
B. Keduanya menyediakan dukungan untuk virtualisasi interupsi, tetapi IOMMU AMD juga
menambahkan kemampuan yang memungkinkan akses sistem operasi tamu mesin virtual yang
aman ke perangkat yang dipilih.
2.24 Buka latihan langsung, tidak ada solusi pasti. 2.25
sebuah. Hasil ini berasal dari eksperimen pada Prosesor Intel® Xeon® X5680 3,3 GHz dengan arsitektur Nehalem
(westmere pada 32 nm). Jumlah miss per 1K instruksi L1 Dcache meningkat secara signifikan lebih
dari 300X ketika ukuran input data berubah dari 8KB menjadi 64 KB, dan menjaga relatif konstan
sekitar 300/1K instruksi untuk semua set data yang lebih besar. Perilaku serupa dengan titik perataan
berbeda pada cache L2 dan L3 diamati.
B. IPC menurun sebesar 60%, 20%, dan 66% ketika ukuran input data berubah dari 8KB menjadi
128 KB, dari 128KB menjadi 4MB, dan dari 4MB menjadi 32MB.
Ini menunjukkan pentingnya semua cache. Di antara ketiga level tersebut, cache L1 dan L3 lebih
penting. Ini karena cache L2 di Intel® Xeon®
Prosesor X5680 relatif kecil dan lambat, dengan kapasitas 256KB dan latensi sekitar 11 siklus.
C. Untuk prosesor Intel i7 terbaru (3.3GHz Intel® Xeon® Processor X5680), saat ukuran kumpulan data
ditingkatkan dari 8KB menjadi 128KB, jumlah L1 Dcache yang terlewat per 1K instruksi meningkat
sekitar 300, dan jumlah L2 cache yang hilang per 1K instruksi tetap dapat diabaikan. Dengan penalti
11 cycle miss, ini berarti bahwa tanpa prefetching atau toleransi latensi dari masalah out-of-order,
kami berharap akan ada 3300 cycle tambahan per 1K instruksi karena L1 miss, yang berarti
peningkatan 3,3 cycle per instruksi pada rata- rata. CPI terukur dengan ukuran data input 8KB
adalah 1,37. Tanpa mekanisme toleransi latensi apa pun, kami mengharapkan CPI kasus 128KB
menjadi 1,37 + 3,3 = 4,67. Namun, CPI terukur dari casing 128KB adalah 3,44. Ini berarti bahwa
teknik menyembunyikan latensi memori seperti eksekusi OOO, prefetching, dan non-blocking cache
meningkatkan kinerja lebih dari 26%.

Bab 3 Solusi ÿ 13
Bab 3 Solusi
Studi Kasus 1: Menjelajahi Dampak Arsitektur Mikro
Teknik
3.1 Performa dasar (dalam siklus, per loop iterasi) dari urutan kode pada Gambar 3.48, jika tidak ada eksek
Lingkaran: LD F2,0(Rx) 1+4
DIVD F8,F2,F0 1 + 12
MULTD F2,F6,F2 1+5
LD F4,0(Ry) 1+4
TAMBAH F4,F0,F4 1+1
TAMBAH F10,F8,F2 1+1
ADDI Rx,Rx,#8 1
ADDI Ry, Ry, #8 1
SD F4,0(Ry) 1+1
SUB R20,R4,Rx 1
BNZ R20, Putaran 1+1
siklus per loop iter 40
Gambar S.2 Kinerja dasar (dalam siklus, per loop iterasi) dari urutan kode pada Gambar 3.48.
3.2 Berapa banyak siklus yang diperlukan oleh badan loop dalam urutan kode pada Gambar 3.48 jika pipeline
mendeteksi dependensi data yang sebenarnya dan hanya terhenti pada hal tersebut, daripada
menghentikan semuanya hanya karena satu unit fungsional sedang sibuk? Jawabannya adalah 25, seperti
yang ditunjukkan pada Gambar S.3. Ingat, inti dari siklus latensi ekstra adalah untuk memungkinkan
instruksi menyelesaikan tindakan apa pun yang
diperlukan, untuk menghasilkan keluaran yang benar. Sampai output itu siap, tidak ada instruksi
dependen yang dapat dieksekusi. Jadi LD pertama harus menghentikan instruksi
berikutnya selama tiga siklus clock. MULTD memberikan hasil untuk penggantinya, dan karena
itu harus menghentikan 4 jam lagi, dan seterusnya.

Lingkaran: LD F2,0(Rx) 1+4
<kios>
<kios>
<kios>
<kios>
DIVD F8,F2,F0 1 + 12
MULTD F2,F6,F2 1+5

LD F4,0(Ry) 1+4
<macet karena latensi LD>

TAMBAHF4,F0,F4
1+1
<macet karena latensi ADDD>

<macet karena latensi DIVD>
TAMBAH F10,F8,F2 1+1
ADDI Rx,Rx,#8 1
ADDI Ry, Ry, #8 1
SD F4,0(Ry) 1+1
SUB R20,R4,Rx 1
BNZ R20, Putaran 1+1
<slot tunda cabang kios>
Gambar S.3 Jumlah siklus yang dibutuhkan oleh badan loop dalam urutan
kode pada Gambar 3.48.
3.3 Pertimbangkan desain multi-masalah. Misalkan Anda memiliki dua pipa eksekusi, masing-masing mampu memulai
eksekusi satu instruksi per siklus, dan mengambil/mendekode bandwidth yang cukup di bagian depan sehingga
tidak akan menghentikan eksekusi Anda. Asumsikan hasil dapat segera diteruskan
dari satu unit eksekusi ke yang lain, atau ke unit itu sendiri.
Asumsikan lebih lanjut bahwa satu-satunya alasan pipa eksekusi terhenti adalah untuk mengamati
ketergantungan data yang sebenarnya. Sekarang berapa banyak siklus yang dibutuhkan loop?
Jawabannya adalah 22, seperti yang ditunjukkan pada Gambar S.4. LD berjalan lebih dulu, seperti sebelumnya,
dan DIVD harus menunggunya melalui 4 siklus latensi tambahan. Setelah DIVD muncul
MULTD, yang dapat berjalan di pipa kedua bersama dengan DIVD, karena tidak ada ketergantungan di antara keduanya. (Perhatikan
bahwa keduanya memerlukan input yang sama, F2, dan keduanya harus menunggu
kesiapan F2, tetapi tidak ada kendala di antara keduanya.) LD yang mengikuti MULTD tidak bergantung pada
DIVD atau MULTD, demikian juga mesin superscalar-order-3,

Bab 3 Solusi ÿ 15
Pipa eksekusi 0 Pipa eksekusi 1
Lingkaran: LD F2,0(Rx) ; <tidak>

; <tidak>
<stall untuk latensi LD> <stall untuk latensi LD> <stall untuk latensi LD> <stall untuk latensi LD>
; <tidak>
DIVDF8,F2,F0 ; <tidak>
LDF4,0(Ry)
; <tidak>
; MULTD
; <tidak>
; <tidak>
; <tidak> F2,F6,F2
; <tidak>
; <tidak>
; <tidak>
<stall untuk latensi LD> <stall untuk latensi LD> <stall untuk latensi LD> <stall untuk
latensi LD> ; <tidak>
; <tidak>
; <tidak>
; <tidak>
; <tidak>
; <tidak>
MENAMBAHKAN
F4,F0,F4 ; ADDI
<macet karena latensi DIVD> ; SD
<macet karena latensi DIVD> ; BNZ
F10,F8,F2
Ry, Ry, #8 R20,R4,Rx
TAMBAH Rx,Rx,#8
F4,0(Ry) R20,
ADDI
SUB
<tidak>Putar ; <stall karena BNZ>
Gambar S.4 Jumlah siklus yang diperlukan per putaran.
bahwa LD dapat dieksekusi bersamaan dengan DIVD dan MULTD. Karena masalah ini menempatkan
mesin dua-pipa-eksekusi, LD mengeksekusi dalam siklus mengikuti DIVD/MULTD. Instruksi overhead
loop di bagian bawah loop juga menunjukkan beberapa potensi konkurensi karena mereka tidak bergantung
pada instruksi latensi panjang.
3.4 Kemungkinan jawaban:
1. Jika interupsi terjadi antara N dan N + 1, maka N + 1 tidak boleh diizinkan untuk menulis hasilnya ke
keadaan arsitektur permanen apa pun. Sebagai alternatif, diperbolehkan untuk menunda interupsi sampai
N +1 selesai.
2. Jika N dan N + 1 kebetulan menargetkan register atau status arsitektur yang sama (katakanlah, memori),
maka mengizinkan N untuk menimpa apa yang ditulis N + 1 akan salah.
3. N mungkin merupakan operasi floating-point panjang yang akhirnya menjebak. N + 1 tidak bisa
diizinkan untuk mengubah status arch jika N akan dicoba lagi.

Operasi latensi panjang memiliki risiko tertinggi untuk diteruskan oleh operasi berikutnya. Instr DIVD akan
selesai jauh setelah LD F4,0(Ry), misalnya.
3.5 Gambar S.5 menunjukkan satu cara yang mungkin untuk menyusun ulang instruksi untuk meningkatkan kinerja
kode pada Gambar 3.48. Jumlah siklus yang diambil kode yang disusun ulang ini adalah 20.
Lingkaran: LD F2,0(Rx) ; LD F4,0(Ry)

<stall untuk latensi LD> ; <stall untuk latensi LD>
DIVD F8,F2,F0 ; TAMBAH F4,F0,F4
MULTD F2,F6,F2 ; <stall karena latensi ADDD>
<macet karena latensi DIVD> ; SD F4,0(Ry)
<macet karena latensi DIVD> ; <tidak> #ops: 11
<macet karena latensi DIVD> ; <tidak> #nops: (20 × 2) – 11 = 29
<macet karena latensi DIVD> ; ADDI Rx,Rx,#8
<macet karena latensi DIVD> ; ADDI Ry, Ry, #8
<macet karena latensi DIVD> ; <tidak>
<macet karena latensi DIVD> ; SUB R20,R4,Rx

TAMBAH F10,F8,F2 ; BNZ R20, Putaran
<tidak> ; <stall karena BNZ>
Gambar S.5 Jumlah siklus yang diambil oleh kode yang disusun ulang.
3.6 sebuah. Pecahan dari semua siklus, menghitung kedua pipa, terbuang dalam kode yang disusun ulang yang
ditunjukkan pada
Gambar S.5: 11 operasi dari peluang 2x20. 1 –

11/40 = 1 – 0,275
= 0,725
B. Hasil membuka gulungan dua iterasi loop dari kode ditunjukkan pada Gambar S.6: c. Mempercepat waktu
eksekusi tanpa peningkatan
-------------------------------------------------- ------------------
= waktu eksekusi dengan peningkatan
Percepatan = 20 / (22/2)
= 1,82

Bab 3 Solusi ÿ 17
Lingkaran: LD F2,0(Rx) ; LD F4,0(Ry)

LD F2,0(Rx) ; LD F4,0(Ry) ;
<stall untuk latensi LD> <stall
<stall untuk latensi LD> ; <stall untuk
untuk latensi LD> <stall untuk
latensi LD> ; <stall untuk latensi LD>
latensi LD>
MULTD F2,F0,F2 ; SD F4,0(Ry)
MULTD F2,F6,F2 ; SD F4,0(Ry)
<macet karena latensi DIVD> <macet ; <tidak>
karena latensi DIVD> <macet karena ; ADDI Rx,Rx,#16
latensi DIVD> <macet karena latensi ; ADDI Ry, Ry, #16
DIVD> <macet karena latensi DIVD> ; <tidak>
karena latensi DIVD ke latensi DIVD> ; <tidak>
karena latensi DIVD> <macet karena ; <tidak>
latensi DIVD> ; <tidak>
; <tidak>
TAMBAH F10,F8,F2 ; SUB R20,R4,Rx

TAMBAH F10,F8,F2 ; BNZ R20,
<tidak> Putar ; <stall karena BNZ>
Gambar S.6 Membuka gulungan dua iterasi loop dari kode yang ditunjukkan pada Gambar S.5.
3.7 Perhatikan urutan kode pada Gambar 3.49. Setiap kali Anda melihat daftar tujuan dalam kode, gantikan
T berikutnya yang tersedia, dimulai dengan T9. Kemudian perbarui semua register src (sumber)
yang sesuai, sehingga dependensi data yang sebenarnya dipertahankan. Tunjukkan kode yang
dihasilkan. (Petunjuk: Lihat Gambar 3.50.)
Lingkaran: LD T9,0(Rx)
AKU: MULTD T10,F0,T2
I1: DIVD T11,T9,T10
I2: LD T12,0(Ry)
I3: TAMBAH T13,F0,T12
I4: SUBD T14,T11,T13
I5: SD T14,0(Ry)
Gambar S.7 Daftar mengubah nama.

3.8 Lihat Gambar S.8. Tabel rename memiliki nilai arbitrer pada siklus clock N – 1. Lihat dua instruksi
berikutnya (I0 dan I1): I0 menargetkan register F1, dan I1 akan menulis register F4. Ini berarti bahwa
dalam siklus jam N, tabel rename akan memiliki entri 1 dan 4 yang ditimpa dengan penanda register
Temp berikutnya yang tersedia. I0 diganti namanya terlebih dahulu, sehingga mendapat T reg pertama
(9). I1 kemudian diganti namanya menjadi T10. Dalam siklus jam N, instruksi I2 dan I3 muncul; I2
akan menimpa F6, dan I3 akan menulis F0. Ini berarti entri rename tabel 6 mendapat 11 (T reg
berikutnya yang tersedia), dan rename tabel entri 0 ditulis ke T reg setelah itu (12). Pada prinsipnya,
Anda tidak perlu mengalokasikan T reg secara berurutan, tetapi jauh lebih mudah di perangkat keras
jika Anda melakukannya.
saya0: SUBD F1,F2,F3

Berganti nama dalam siklus N
I1: TAMBAH F4,F1,F2
I2: MULTD F6,F4,F1

Berganti nama dalam siklus N + 1
I3: DIVD F0,F2,F6
Siklus jam
N –1 N N +1
0 0 0 0 0 12
1 1 1 9 1 1
2 2 2 2 2 2
3 3 3 3 3 3
4 4 4 10 4 4
5 5 5 5 5 5
6 6 6 6 6 11
7 7 7 7 7 7
8 8 8 8 8 8
9 9 9 9 9 9
62 62 62 62 62 62
63 63 63 63 63 63
12 11 10 9 14 13 12 11 16 15 14 13
Tersedia berikutnya
T reg
Gambar S.8 Keadaan siklus demi siklus dari tabel ganti nama untuk setiap instruksi kode
pada Gambar 3.51.
3.9 Lihat Gambar S.9.
MENAMBAHKAN
R1, R1, R1; 5 + 5 ÿ> 10
MENAMBAHKAN
R1, R1, R1; 10 + 10 ÿ> 20
MENAMBAHKAN
R1, R1, R1; 20 + 20 ÿ> 40
Gambar S.9 Nilai R1 saat sequence telah dieksekusi.

Bab 3 Solusi ÿ 19
3.10 Contoh kejadian yang, dengan adanya jaringan pipa yang menguras sendiri, dapat merusak
merusak pipa dan menghasilkan hasil yang salah ditunjukkan pada Gambar S.10.
alu0 alu1 ld/st ld/st br
Jam 1 ADDI R11, R3, #2 LWR4, 0(R0)

siklus
2 ADDI R2, R2, #16
ADDI R20, R0, #2 LWR4, 0(R0) LW R5, 8(R1)
3 LW R5, 8(R1)
4 ADDI R10, R4, #1
5 ADDI R10, R4, #1 SW R7, 0(R6) SW R9, 8(R8)
6 SUB R4, R3, R2 SW R7, 0(R6) SW R9, 8(R8)
7 BNZ R4, Loop
Gambar S.10 Contoh kejadian yang menghasilkan hasil yang salah. Apa yang salah dengan ini? Jika
interupsi diambil antara clock cycle 1 dan 4, maka hasil LW pada cycle 2 akan berakhir di R1, bukannya LW pada
cycle 1. Stop bank dan stop ECC akan menyebabkan efek yang sama—pipa akan terkuras, dan penulis terakhir
menang, bahaya WAW klasik.
Semua hasil "menengah" lainnya hilang.
3.11 Lihat Gambar S.11. Konvensinya adalah bahwa instruksi tidak memasuki fase eksekusi sampai semua
operannya siap. Jadi instruksi pertama, LW R3,0(R0), berjalan melalui tiga tahap pertamanya (F, D,
E) tetapi tahap M berikutnya membutuhkan siklus biasa ditambah dua lagi untuk latensi. Hingga
data dari LD tersedia di unit eksekusi, setiap instruksi berikutnya (khususnya ADDI R1, R1, #1,
yang bergantung pada LW ke-2) tidak dapat masuk ke tahap E, dan karena itu harus terhenti di tahap
D.
Panjang lingkaran
Lingkaran: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
F D e M – –
LW R3,0(R0) W
LW R1,0(R3) F D – – – e M – – W
F – – – D – – – e M
ADDI R1,R1,#1 W
F – – – D e M
SUB R4,R3,R2 W
F D e M – – W
SW R1,0(R3)
F D e – – M
BNZ R4, Loop W
LW R3,0(R0) F D ...
(2.11a) 4 siklus hilang ke overhead cabang
(2.11b) 2 siklus hilang dengan prediktor statis
(2.11c) Tidak ada siklus yang hilang dengan prediksi dinamis yang benar
Gambar S.11 Fase dari setiap instruksi per siklus clock untuk satu iterasi loop.

A. 4 siklus hilang ke overhead cabang. Tanpa melewati, hasil instruksi SUB tidak tersedia sampai tahap W
SUB. Itu berlaku pada 4 siklus clock ekstra di akhir loop, karena LW R1 loop berikutnya tidak dapat
dimulai sampai cabang selesai.
B. 2 siklus hilang dengan prediktor statis. Prediktor cabang statis mungkin memiliki heuristik seperti
"jika target cabang adalah offset negatif, anggap itu adalah tepi loop, dan loop biasanya diambil
cabang." Tapi kami masih harus mengambil dan mendekodekan cabang untuk melihatnya, jadi
kami masih kehilangan 2 siklus jam di sini.
C. Tidak ada siklus yang hilang dengan prediksi dinamis yang benar. Prediktor cabang dinamis mengingat
bahwa ketika instruksi cabang diambil di masa lalu, akhirnya berubah menjadi cabang, dan cabang ini
diambil. Jadi "diprediksi diambil" akan terjadi dalam siklus yang sama dengan pengambilan cabang,
dan pengambilan berikutnya setelah itu akan menjadi target yang diperkirakan. Jika benar, kami telah
menyimpan semua siklus latensi yang terlihat di
3.11 (a) dan 3.11 (b). Jika tidak, kami harus melakukan pembersihan.
3.12 sebuah. Lihat Gambar S.12.
LD
F2,0(Rx)
DIVD
F8,F2,F0
MULTD
F2,F8,F2 ; penggantian nama reg tidak terlalu membantu di sini, karena ; dependensi data
sebenarnya pada F8 dan F2 ; LD ini tidak tergantung
LD F4,0(Ry) pada 3 sebelumnya; instrs dan dapat dilakukan lebih awal dari ; pesanan pgm Itu memberi makan ADDD berikutnya, dan ADDD ; me
ketergantungan melalui semua, jadi tidak ada manfaatnya
TAMBAH F4,F0,F4
TAMBAH F10,F8,F2 ; ADDD ini masih harus menunggu latensi DIVD, ; tidak peduli apa yang Anda
sebut reg pertemuan mereka; ganti nama untuk iterasi loop berikutnya; ganti
ADDI Rx,Rx,#8 nama untuk iterasi loop berikutnya; SD ini dapat
ADDI Ry, Ry, #8 dimulai saat latensi ADDD telah ; terjadi. Dengan
SD F4,0(Ry) penggantian nama reg, tidak ada ; menunggu sampai LD dari F4 (berbeda)
memiliki ; lengkap.
SUB R20,R4,Rx
BNZ R20, Putaran
Gambar S.12 Instruksi dalam kode di mana penamaan ulang register meningkatkan kinerja.

Bab 3 Solusi ÿ 21
B. Lihat Gambar S.13. Jumlah siklus jam yang diambil oleh urutan kode adalah 25.
Operasi siklus dikirim ke FU
alu0 alu1 ld/st

1
Siklus jam ADDI Rx,Rx,#8 ADDI Ry, Ry, #8 LD F2,0(Rx)
2
SUB R20,R4,Rx LD F4,0(Ry)
Catatan: ADDI ini 3
latensi LD
menghasilkan Rx,y untuk

iterasi loop berikutnya, bukan yang 4ini.
6 DIVD F8,F2,F0
7 TAMBAHKAN F4,F0,F4
8
ADD latensi
... SD F4,0(Ry)
18
19 MULTD F2,F8,F2
20
21
latensi MULTD
22
23
24 BNZ R20, Lingkaran
25 Bayangan cabang TAMBAHKAN F10,F8,F2
Gambar S.13 Jumlah siklus jam yang diambil oleh urutan kode.
C. Lihat Gambar S.14 dan S.15. Instruksi yang dicetak tebal adalah instruksi yang ada
di RS, dan siap dikirim. Pikirkan latihan ini dari sudut pandang Stasiun Reservasi:
pada siklus waktu tertentu, ia hanya dapat "melihat" instruksi yang sebelumnya
ditulis ke dalamnya, yang belum dikirim. Dari kumpulan itu, tugas RS adalah
mengidentifikasi dan mengirim dua instruksi yang memenuhi syarat yang akan
paling meningkatkan kinerja alat berat.
0 1 2 3 4 5 6
LD F2, 0(Rx) LD F2, 0(Rx) LD F2, 0(Rx) LD F2, 0(Rx) LD F2, 0(Rx) LD F2, 0(Rx)
DIVD F8,F2,F0 DIVD F8,F2,F0 DIVD F8,F2,F0 DIVD F8,F2,F0 DIVD F8,F2,F0 DIVD F8,F2,F0
MULTD F2,F8,F2 MULTD F2,F8,F2 MULTD F2,F8,F2 MULTD F2,F8,F2 MULTD F2,F8,F2 MULTD F2,F8,F2
LD F4, 0(Ry) LD F4, 0(Ry) LD F4, 0(Ry) LD F4, 0(Ry) LD F4, 0(Ry) LD F4, 0(Ry)
TAMBAH F4,F0,F4 TAMBAH F4,F0,F4 TAMBAH F4,F0,F4 TAMBAH F4,F0,F4 TAMBAH F4,F0,F4 TAMBAH F4,F0,F4
TAMBAH F10,F8,F2 TAMBAH F10,F8,F2 TAMBAH F10,F8,F2 TAMBAH F10,F8,F2 TAMBAH F10,F8,F2 TAMBAH F10,F8,F2
ADDI Rx,Rx,#8 ADDI Rx,Rx,#8 ADDI Rx,Rx,#8 ADDI Rx,Rx,#8 ADDI Rx,Rx,#8 ADDI Rx,Rx,#8
ADDI Ry, Ry, #8 ADDI Ry, Ry, #8 ADDI Ry, Ry, #8 ADDI Ry, Ry, #8 ADDI Ry, Ry, #8 ADDI Ry, Ry, #8
SD F4,0(Ry) SD F4,0(Ry) SD F4,0(Ry) SD F4,0(Ry) SD F4,0(Ry) SD F4,0(Ry)
SUB R20,R4,Rx SUB R20,R4,Rx SUB R20,R4,Rx SUB R20,R4,Rx SUB R20,R4,Rx SUB R20,R4,Rx
BNZ 20, Lingkaran BNZ 20, Lingkaran BNZ 20, Lingkaran BNZ 20, Lingkaran BNZ 20, Lingkaran BNZ 20, Lingkaran
2 instruksi pertama muncul di Kandidat RS untuk dikirim dalam huruf tebal
Gambar S.14 Kandidat untuk dikirim.

alu0 alu1 ld/st
1 LD F2,0(Rx)
2 LD F4,0(Ry)
4 ADDI Rx,Rx,#8
5 ADDI Ry, Ry, #8
6 SUB R20,R4,Rx DIVD F8,F2,F0
Siklus jam 9 SD F4,0(Ry)
...
18
19 MULTD F2,F8,F2
20
21
22
23
25 TAMBAHKAN F10,F8,F2 Bayangan cabang
Total 25 siklus jam
alu0 alu1 ld/st
1 LD F2,0(Rx)
Siklus jam 2 LD F4,0(Ry)
Gambar S.15 Jumlah3 siklus clock yang diperlukan.

D. Lihat Gambar S.16.4 ADDI Rx,Rx,#8
5 ADDI Ry, Ry, #8
9 SD F4,0(Ry)
...
18
19 MULTD F2,F8,F2
20
21
22
23
Total 25 siklus jam
Gambar S.16 Percepatan adalah (waktu eksekusi tanpa peningkatan)/(waktu

eksekusi dengan peningkatan) = 25/(25 – 6) = 1,316.

Bab 3 Solusi ÿ 23
1. ALU lainnya: peningkatan 0% 2. Unit LD/ST

lainnya: peningkatan 0% 3. Pelewatan
penuh: jalur kritis adalah LD -> Div -> MULT -> ADDD. Memotong akan menghemat 1
siklus dari latensi masing-masing, jadi total 4 siklus 4.
Memotong latensi terpanjang menjadi dua: pembagi terpanjang pada 12 siklus. Ini akan
menghemat total 6
siklus. e. Lihat Gambar S.17.
alu0 alu1 ld/st
1 LD F2,0(Rx)
Siklus jam 2 LD F2,0(Rx)
3 LD F4,0(Ry)
4 ADDI Rx,Rx,#8
5 ADDI Ry, Ry, #8
7 DIVD F8,F2,F0
... SD F4,0(Ry)
18
19 MULTD F2,F8,F2
20 MULTD F2,F8,F2
21
22
23
24
25 TAMBAHKAN F10,F8,F2 BNZ R20, Lingkaran
Total 26 siklus jam
Gambar S.17 Jumlah siklus jam yang diperlukan untuk melakukan pekerjaan senilai dua
putaran. Jalur kritis adalah LD -> DIVD -> MULTD -> ADDD. Jika RS menjadwalkan LD kritis loop ke-2
dalam siklus 2, maka rantai ketergantungan kritis loop 2 akan memiliki panjang yang sama dengan loop 1.
Karena kita bukan unit-fungsional-terbatas untuk kode ini, hanya diperlukan satu siklus clock tambahan.

Latihan
Siklus jam Kode tidak terjadwal Kode terjadwal
1 DADDIU R4,R1,#800 DADDIU R4,R1,#800

2 LD F2,0(R1) LD F2,0(R1)
3 macet LD F6,0(R2)
4 MUL.D F4,F2,F0 MUL.D F4,F2,F0
5 LD F6,0(R2) DADDIU R1,R1,#8
6 macet DADDIU R2,R2,#8
macet DSLTU R3,R1,R4
macet macet
macet macet
7 TAMBAH.D F6,F4,F6 TAMBAH.D F6,F4,F6

8 macet macet
9 macet macet
10 macet BNEZ R3, foo

11 SD F6,0(R2) SD F6,-8(R2)
12 DADDIU R1,R1,#8
13 DADDIU R2,R2,#8
14 DSLTU R3,R1,R4
15 macet
16 BNEZ R3, foo

17 macet
Gambar S.18 Waktu eksekusi per elemen untuk kode tidak terjadwal adalah 16 siklus jam dan untuk
kode terjadwal adalah 10 siklus jam. Ini 60% lebih cepat, jadi jam harus 60% lebih cepat agar kode yang tidak terjadwal cocok dengan kinerja kod
B. Lihat Gambar S.19.
Siklus jam Kode terjadwal
1 DADDIU R4,R1,#800
2 LD F2,0(R1)
3 LD F6,0(R2)
4 MUL.D F4,F2,F0
Gambar S.19 Kode harus dibuka gulungannya tiga kali untuk menghilangkan kemacetan
setelah penjadwalan.

Bab 3 Solusi ÿ 25
5 LD F2,8(R1)
6 LD F10,8(R2)
7 MUL.D F8,F2,F0
8 LD F2,8(R1)
9 LD F14,8(R2)
10 MUL.D F12,F2,F0
11 TAMBAH.D F6,F4,F6
12 DADDIU R1,R1,#24
14 DADDIU R2,R2,#24
15 DSLTU R3,R1,R4
17 SD F6,-24(R2)
18 SD F10,-16(R2)
19 BNEZ R3, foo
20 SD F14,-8(R2)
Gambar S.19 Lanjutan
C. Lihat Gambar S.20 dan S.21.

Digulung 6 kali:
Referensi Referensi Operasi bilangan

Siklus memori 1 memori 2 Operasi FP 1 Operasi FP2 bulat/cabang
1 LD F1,0(R1) LD F2,8(R1)
2 LD F3,16(R1) LD F4,24(R1)
3 LD F5,32(R1) LD F6,40(R1) MUL.D F1,F1,F0 MUL.D F2,F2,F0
4 LD F7,0(R2) LD F8,8(R2) MUL.D F3,F3,F0 MUL.D F4,F4,F0
5 LD F9,16(R2) LD F10,24(R2) MUL.D F5,F5,F0 LD F12,40(R2) MUL.D F6,F6,F0
6 LD F11,32(R2)
7 DADDIU
R1,R1,48
8 DADDIU
R2,R2,48
Gambar S.20 15 siklus untuk 34 operasi, menghasilkan 2,67 masalah per jam, dengan efisiensi VLIW 34 operasi untuk 75 slot =
45,3%. Jadwal ini membutuhkan 12 register floating-point.


12 DSLTU
R3,R1,R4
13 SD F7,-48(R2) SD F8,-40(R2)
14 SD F9,-32(R2) SD F10,-24(R2)
15 SD F11,-16(R2) SD F12,-8(R2)
BNEZ R3, foo
Dibuka 10 kali:
Referensi Referensi Operasi

Siklus memori 1 memori 2 Operasi FP 1 Operasi FP2 bilangan bulat/cabang
1 LD F1,0(R1) LD F2,8(R1)
2 LD F3,16(R1) LD F4,24(R1)
3 LD F5,32(R1) LD F6,40(R1) MUL.D F1,F1,F0 LD F7,48(R1) MUL.D F2,F2,F0
4 LD F8,56(R1) MUL.D F3,F3,F0 LD F9,64(R1) MUL.D F4,F4,F0
5 LD F10,72(R1) MUL.D F5,F5,F0 LD MUL.D F6,F6,F0
6 F11,0(R2) LD F12,8(R2) MUL.D F7,F7,F0 LD MUL.D F8,F8,F0
7 F13,16(R2) LD F14,24(R2) MUL.D F9,F9,F0 LD F15,32(R2) LD MUL.D F10,F10,F0 DADDIU R1,R1,48
8 F16,40(R2 ) DADDIU R2,R2,48
9 LD F17,48(R2) LD F18,56(R2) TAMBAH.D F11,F11,F1 TAMBAH.D F12,F12,F2 10 LD F19,64(R2)
LD F20,72(R2) TAMBAH.D F13, F13,F3 ADD.D F14,F14,F4

11
TAMBAH.D F15,F15,F5 TAMBAH.D F16,F16,F6
12
TAMBAH.D F17,F17,F7 TAMBAH.D F18,F18,F8 DSLTU R3,R1,R4
13 SD F11,-80(R2) SD F12,-72(R2) TAMBAH.D F19,F19,F9 TAMBAH.D F20,F20,F10 14 SD F13,-64(R2) SD F14,-

56(R2)
15 SD F15,-48(R2) SD F16,-40(R2)
16 SD F17,-32(R2) SD F18,-24(R2)
17 SD F19,-16(R2) SD F20,-8(R2) BNEZ R3, foo
Gambar S.21 17 siklus untuk 54 operasi, menghasilkan 3,18 masalah per jam, dengan efisiensi VLIW 54 operasi untuk 85 slot =
63,5%. Jadwal ini membutuhkan 20 register floating-point.

Bab 3 Solusi ÿ 27
Eksekusi/
Instruksi Iterasi Masalah di Memori Tulis CDB di Komentar
1 LD F2,0(R1) 1 2 3 Masalah pertama
1 MUL.D F4,F2,F0 2 419 Tunggu F2

Banyak rs [3–4]
Banyak penggunaan [5–18]
1 LD F6,0(R2) 3 4 5 Ldbuf [4]

1 ADD.D F6,F4,F6 4 20 30 Tunggu F4
Tambahkan rs [5–20]
Tambahkan penggunaan [21–29]
1 SD F6,0(R2) 5 31 Tunggu F6
Stbuf1 [6–31]
1 DADDIU R1,R1,#8 678 DADDIU R2,R2,#8 789 DSLTU R3,R1,R4 BNEZ 1
R3,foo LD F2,0(R1)
1 8 910
1 9 11 Tunggu R3
2 10 12 13 Tunggu BNEZ
Ldbuf [11–12]
2 MUL.D F4,F2,F0 11 14 34 Tunggu F2
19 Sangat sibuk
Banyak rs [12–19]
2 LD F6,0(R2) 12 13 14 Ldbuf [13]

2 SD F6,0(R2) 14 46 Tunggu F6
Stbuf [15–46]
2 DADDIU R1,R1,#8 15 16 17
2 DADDIU R2,R2,#8 16 17 18
2 DSLTU R3,R1,R4 17 18 20
2 BNEZ R3,foo 18 20 Tunggu R3
3 LD F2,0(R1) 19 21 22 Tunggu BNEZ

Ldbuf [20–21]
34 Sangat sibuk
Banyak rs [21–34]
3 LD F6,0(R2) 21 22 23 Ldbuf [22]

Gambar S.22 Solusi untuk latihan 3.14a.

3 SD F6,0(R2) 23 55 Tunggu F6
Stbuf [24–55]
3 DADDIU R1,R1,#8 24 25 26
3 DADDIU R2,R2,#8 25 26 27
3 DSLTU R3,R1,R4 26 27 28
3 BNEZ R3, foo 27 29 Tunggu R3
B. Lihat Gambar S.23.
Eksekusi/
Pengulangan Petunjuk Masalah di Penyimpanan Tulis CDB di Komentar
1 LD F2,0(R1) 1 2 3

Banyak rs [2–4]
Banyak penggunaan [5]
1 LD F6,0(R2) 2 3 4 Ldbuf [3]

Tambahkan penggunaan [21]
1 SD F6,0(R2) 3 31 Tunggu F6
Stbuf [4–31]
1 DADDIU R1,R1,#8 3 4 5
1 DADDIU R2,R2,#8 4 5 6
1 DSLTU R3,R1,R4 4 6 7 INT sibuk

INT rs [5–6]
1 BNEZ R3, foo 5 7 INT sibuk
INT rs [6–7]
2 LD F2,0(R1) 6 8 9 Tunggu BEQZ
Banyak rs [7–10]
2 LD F6,0(R2) 7 9 10 INT sibuk

INT rs [8–9]
Tambahkan RS [8–26]
2 SD F6,0(R2) 8 37 Tunggu F6
2 DADDIU R1,R1,#8 8 10 11 INT sibuk

INT rs [8–10]
Gambar S.23 Solusi untuk latihan 3.14b.

Bab 3 Solusi ÿ 29
2 DADDIU R2,R2,#8 12
9 11 INT sibuk
INT rs [10–11]
2 DSLTU R3,R1,R4 13
INT sibuk
9 12
INT rs [10–12]
2
BNEZ R3,foo LD Tunggu R3
10 14
3 F2,0(R1) 16 Tunggu BNEZ
11 15
3
MUL.D F4,F2,F0 32 Tunggu F2
11 17
Banyak rs [12–17]
3 LD F6,0(R2) 17
12 16 INT sibuk
INT rs [13–16]
3 ADD.D F6,F4,F6 43 Tunggu F4
12 33
3 SD F6,0(R2) 14 44 Tunggu F6
INT rs penuh dalam 15
3 DADDIU R1,R1,#8 15 17 INT rs penuh dan sibuk

INT rs [17]
3 DADDIU R2,R2,#8 16 18 INT rs penuh dan sibuk
INT rs [18]
3 DSLTU R3,R1,R4 20 21 INT rs penuh
3 BNEZ R3, foo 21 22 INT rs penuh
3.15 Lihat Gambar S.24.
Petunjuk
Masalah di Eksekusi/Memori Tulis CDB di
ADD.D F2,F4,F6
1 2 12
TAMBAH R1,R1,R2
2 3 4
TAMBAH R1,R1,R2
3 5 6
TAMBAH R1,R1,R2
4 7 8
TAMBAH R1,R1,R2
5 9 10
TAMBAH R1,R1,R2 6 11 12 (konflik CDB)
Gambar S.24 Solusi untuk latihan 3.15.

3.16 Lihat Gambar S.25 dan S.26.

Prediktor Korelasi
Mod komputer
cabang 4
Hasil Prediksi Salah Prediksi? Pembaruan Tabel
Pintu masuk
2 4 T T TIDAK tidak ada
3 6 PB PB TIDAK
ubah menjadi "NT"
1 2 PB PB TIDAK tidak ada
1 3 T PB Ya ubah menjadi "T dengan satu salah prediksi"
1 3 T PB Ya ubah menjadi "NT"
3 7 PB T Ya ubah menjadi "NT dengan satu kesalahan prediksi"
Gambar S.25 Hasil masing-masing cabang, dalam urutan eksekusi. Tingkat salah prediksi = 3/9 = 0,33.
Prediktor Lokal
Cabang PC mod 2 Pintu masuk

Ramalan Hasil Salah prediksi? Pembaruan Tabel
0 0 T T TIDAK
ubah ke "T" ubah
1 4 T PB Ya ke "T dengan satu kesalahan

prediksi"
1 3 T PB Ya ubah ke "T dengan satu

kesalahan prediksi"
1 3 T PB Ya ubah ke "NT"
1 5 T T TIDAK ubah menjadi "T"
Gambar S.26 Hasil cabang individu, dalam urutan eksekusi. Tingkat salah prediksi = 3/9 = 0,33.

Bab 3 Solusi ÿ 31
3.17 Untuk soal ini kita diberikan IHK dasar tanpa warung cabang. Dari sini kita dapat menghitung jumlah
kios yang diberikan oleh tanpa BTB dan dengan BTB: CPInoBTB dan CPIBTB dan hasil
percepatan yang diberikan oleh BTB:
CPInoBTB
CPIbase Stallsbase +
= =
Percepatan
CPIBTB Warung CPIbaseBTB +
StallsnoBTB = 15% 2 × = 0,30
Untuk menghitung StallsBTB, perhatikan tabel berikut:
BTB Penalti
Hasil BTB Ramalan Frekuensi (Per Instruksi) (Siklus)
Merindukan 15% × 10% = 1,5% 3
Memukul Benar 15% × 90% × 90% = 12,1% 0
Memukul Salah 15% × 90% × 10% = 1,3% 4
Gambar S.27 Penalti tertimbang untuk kemungkinan hasil cabang.
Karena itu:
= ( ( ) 12,1% 0 × ( ) 1,3% 4 × ) 1,5% 3 × ++ 1 ,2 =

StallsBTB
1,0 0,30 +
-------------------------- =
Percepatan = 1.2
1,0 0,097 +
3.18 a. Menyimpan instruksi target dari cabang tanpa syarat secara efektif menghapus satu instruksi. Jika
ada hit BTB dalam pengambilan instruksi dan instruksi target tersedia, maka instruksi
tersebut dimasukkan ke dalam dekode sebagai pengganti instruksi cabang. Hukumannya
adalah –1 siklus. Dengan kata lain, ini adalah keuntungan kinerja 1 siklus. B. Jika
BTB hanya menyimpan alamat target dari cabang tanpa syarat, ambil harus mengambil instruksi baru.
Ini memberi kita istilah CPI 5% × (90% × 0 + 10% × 2) dari 0,01. Istilah ini mewakili CPI untuk
cabang tanpa syarat (ditimbang berdasarkan frekuensinya sebesar 5%). Jika BTB malah
menyimpan instruksi target, istilah CPI menjadi 5% × (90% × (–1) + 10% × 2) atau –0,035.
Tanda negatif menunjukkan bahwa itu mengurangi nilai CPI secara keseluruhan. Persentase hit
untuk mencapai titik impas hanya 20%.

Bab 4 Solusi
Studi Kasus: Menerapkan Kernel Vektor pada
Vektor Prosesor dan GPU
4.1 Kode MIPS (jawaban dapat bervariasi)
li $r1,#0 # menginisialisasi k
loop: ls $f0,0($RtipL) # memuat semua nilai untuk ekspresi
pertama
$f1,0($RclL) ls
l$sf2,4($RtipL) ls $f3,4($RclL)
$f4,8($RtipL) ls
l$sf5,8($RclL) ls $f6,12( $RtipL)
ls $f7,12($RclL) ls
$lsf8,0($RtipR) ls $f9,0($RclR)
$f10,4($RtipR) ls $f11,4($RclR) ls
$f12,8($RtipR) ls
$f13,8($RclR) ls
$f14,12($RtipR) ls
$f15,12($RclR) banyak
$f16,$f0,$f1 banyak.s $
f17,$f2,$f3 mul.s $f18,$f4,$f5
mul.s $f19,$f6,$f7 tambah.s
$f20,$f16,$f17 tambah.s
$f20,$f20,$ f18 add.s
# empat perkalian pertama
$f20,$f20,$f19 mul.s
$f16,$f8,$f9 mul.s
$f17,$f10,$f11 mul.s
$f18,$f12,$f13 mul.s $f19 , # menumpuk
$f14,$f15 tambahkan.s
$f21,$f16,$f17 tambahkan.s
$f21,$f21,$f18 tambahkan.s
# detik empat dikalikan
$f21,$f21,$f19 lebih dari
$f20,$f20,$f21 $f20,0($RclP) st.s
$RclP,$RclP,#4
# menumpuk
# kalikan akhir #
simpan hasil #
menambahkan kenaikan clP untuk ekspresi
selanjutnya
menambahkan $RtiPL,$RtiPL,#16 # menaikkan tiPL untuk ekspresi berikutnya

Bab 4 Solusi ÿ 33
menambahkan
$RtiPR,$RtiPR,#16 # kenaikan tiPR untuk ekspresi berikutnya
adi
$r1,$r1,#1
dan
$r2,$r2,#3 # periksa apakah kita harus menaikkan
clL dan clR (setiap 4 bit)
bneq $r2, lewati

tambahkan $RclL,$RclL,#16
# kenaikan tiPL untuk iterasi loop berikutnya
menambahkan
$RclR,$RclR,#16 # kenaikan tiPR untuk iterasi loop berikutnya
# asumsikan r3 = seq_length * 4
lewati: blt $r1,$r3,putaran
Kode VMIPS (jawaban dapat bervariasi)
di $r1,#0 di $VL,#4 putaran:

# menginisialisasi
lv
k # menginisialisasi panjang vektor
$v0,0($RclL) lv $v1,0($RclR) lv
$v2,0($RtipL) lv
$v3,16($RtipL) lv
# memuat semua nilai tipL
$v4,32($RtipL) lv
$v5,48($RtipL) lv $v6,0($RtipR) lv
$v7,16($RtipR) lv
$v8,32($RtipR) lv $v9,48 ($RtipR)
# memuat semua nilai tipR
mulvv.s $v2,$v2,$v0
# gandakan sub-
ekspresi kiri
mulvv.s $v3,$v3,$v0
mulvv.s $v4,$v4,$v0
mulvv.s $v5,$v5,$v0
mulvv.s $v6,$v6,$v1 # gandakan sub-
ekspresi kanan
mulvv.s $v7,$v7,$v1
mulvv.s $v8,$v8,$v1
mulvv.s $v9,$v9,$v1
sumr.s $f0,$v2 sumr.s # kurangi sub-ekspresi kiri
$f1,$v3
sumr .s $f2,$v4
sumr.s $f3,$v5
sumr.s $f4,$v6 # kurangi sub- ekspresi
yang tepat
jumlah.s $f5,$v7
jumlah.s $f6,$v8
jumlah.s $f7,$v9
banyak.s $f0,$f0,$f4 # mengalikan sub-ekspresi kiri dan kanan

mul.s $f1,$f1,$f5 mul.s

$f2,$f2,$f6 mul.s $f3,$f3,$f7
$f0,0($Rclp) $f1,4($Rclp)
ss $ f2,8($Rclp) # menyimpan hasil
ss $f3,12($Rclp)
ss
ss
menambahkan
$RtiPL,$RtiPL,#64 # kenaikan tiPL untuk ekspresi berikutnya
$RtiPR,
menambahkan $RtiPR,#64 # kenaikan tiPR untuk ekspresi berikutnya # kenaikan clP
untuk
menambahkan
$RclP,$RclP,#16 ekspresi berikutnya # kenaikan clL
untuk ekspresi
menambahkan
$RclL,$RclL,#16 berikutnya # kenaikan clR untuk
ekspresi
menambahkan
$RclR,$RclR,#16 berikutnya
addi
$r1,$r1,#1
blt
$r1,$r3,ulang # asumsikan r3 = seq_length
4.2 MIPS: loop adalah 41 instruksi, akan mengulang 500 × 4 = 2000 kali, jadi kira-kira 82000
instruksi
VMIPS: loop juga 41 instruksi tetapi hanya akan mengulang 500 kali, jadi kira-kira 20500
instruksi
sumr.s
4.3 1. 2. l
sumr.s
3. v
sumr.s
l mulvv.s mulvv.s mulvv.s mulvv.s mulvv.s mulvv.s mulvv.s mulvv.s
4. v
5. l
6. v
7. l
8. v
9. l
10. v
11. l
12. v
13. l
14. v
15. l
16. v
17. l
18. v
l
v
sumr.s
sumr.s
sumr.s
sumr.s
sumr.s
L # tiPR 0 #
#
# tiPL tiPR 1 #
0 # tiPR 2 #
c tiPL
tiPL tiPR 3
l #
18 lonceng, 4 hasil, 15 FLOPS per hasil, 18/15 = 1,2 siklus per FLOP

Bab 4 Solusi ÿ 35
4.4 Dalam hal ini, 16 nilai dapat dimuat ke dalam setiap register vektor, melakukan perkalian
vektor dari empat iterasi loop dalam instruksi perkalian vektor tunggal. Ini dapat
mengurangi jumlah iterasi loop dengan faktor 4. Namun, tanpa cara untuk melakukan
pengurangan pada subset elemen vektor, teknik ini tidak dapat diterapkan pada kode ini.
4.5 global batal menghitung_condLike (float *clL, float *clR, float
*clP, float *tiPL, float *tiPR) { int i,k = threadIdx.x;
shared
float clL_s[4], clR_s[4];
untuk (i=0;i<4;i++)
{ clL_s[i]=clL[k*4+i];
clR_s[i]=clR[k*4+i];
}
clP[k*4] = (tiPL[k*16+AA]*clL_s[A] +
tiPL[k*16+AC]*clL_s[C] + tiPL[k*16+AG]*clL_s[G] +
tiPL[k*16+AT]*clL_s[T])*(tiPR[k*16+AA]*clR_s[A] +
tiPR[k*16+AC]*clR_s[C] + tiPR[k*16+ AG]*clR_s[G] +
tiPR[k*16+AT]*clR_s[T]);
clP[k*4+1] = (tiPL[k*16+CA]*clL_s[A] +
tiPL[k*16+CC]*clL_s[C] + tiPL[k*16+CG]*clL_s[G ] +
tiPL[k*16+CT]*clL_s[T])*(tiPR[k*16+CA]*clR_s[A] +
tiPR[k*16+CC]*clR_s[C] + tiPR[k* 16+CG]*clR_s[G] +
tiPR[k*16+CT]*clR_s[T]);
clP[k*4+2] = (tiPL[k*16+GA]*clL_s[A] +
tiPL[k*16+GC]*clL_s[C] + tiPL[k*16+GG]*clL_s[G ] +
tiPL[k*16+GT]*clL_s[T])*(tiPR[k*16+GA]*clR_s[A] +
tiPR[k*16+GC]*clR_s[C] + tiPR[k* 16+GG]*clR_s[G] +
tiPR[k*16+GT]*clR_s[T]);
clP[k*4+3] = (tiPL[k*16+TA]*clL_s[A] +
tiPL[k*16+TC]*clL_s[C] + tiPL[k*16+TG]*clL_s[G ] +
tiPL[k*16+TT]*clL_s[T])*(tiPR[k*16+TA]*clR_s[A] +
tiPR[k*16+TC]*clR_s[C] + tiPR[k* 16+TG]*clR_s[G] +
tiPR[k*16+TT]*clR_s[T]); }
4.6 clP[threadIdx.x*4 + blockIdx.x+12*500*4]

clP[threadIdx.x*4+1 + blockIdx.x+12*500*4]
clP[threadIdx.x*4+2+ blockIdx.x+12*500*4]
clP[threadIdx.x*4+3 + blockIdx.x+12*500*4]
clL[threadIdx.x*4+i+ blockIdx.x*2*500*4]
clR[threadIdx.x*4+i+ (blockIdx.x*2+1)*500*4]

tipL[threadIdx.x*16+AA + blockIdx.x*2*500*16]
tipL[threadIdx.x*16+AC + blockIdx.x*2*500*16]
…
tipL[threadIdx.x*16+TT + blockIdx.x*2*500*16]
tipR[threadIdx.x*16+AA + (blockIdx.x*2+1)*500*16]
tipR[threadIdx.x*16+AC +1 + (blockIdx.x*2+1)*500*16]
…
tipR[threadIdx.x*16+TT +15+ (blockIdx.x*2+1)*500*16]

4.7
# hitung alamat clL # gandakan

mul.u64 %r1, %ctaid.x, 4000 indeks blok dengan 4000 # gandakan
mul.u64 %r2, %tid.x, 4 indeks thread dengan 4 # tambahkan
%r1, %r1, %r2 produk # muat
tambahkan.u64 %r2, [clL] alamat basis clL # tambahkan
ld.param.u64 tambahkan.u6%4 r1,%r2,%r2 basis ke offset
# hitung alamat clR #

add.u64 %r2, %ctaid.x,1 tambahkan 1 ke blok indeks #
mul.u64 %r2, %r2, 4000 kalikan dengan 4000
mul.u64 %r3, %tid.x, 4 # kalikan indeks thread dengan 4 #
add.u64 %r2, %r2, %r3 tambahkan
ld.param.u64 %r3, [clR] produk # muat alamat dasar clR #
add.u64 %r2,%r2,%r3 tambahkan basis ke offset
ld.global.f32 %f1, [%r1+0] # pindahkan clL dan clR ke memori bersama #
st.shared.f32 [clL_s+0], %f1 (buka gulungannya)
ld.global.f32 %f1, [%r2+0]
st.shared.f32 [clR_s+0], %f1
st.shared.f32
[clL_s+4], % f1
st.shared.f32
[clR_s+4], %f1
st.shared.f32
[clL_s+8], %f1
st.shared.f32
[clR_s+8], %f1
st.shared.f32
[clL_s+12], %f1
st.shared.f32
[clR_s+12], %f1
# hitung alamat tiPL: # gandakan indeks
mul.u64
%r1, %ctaid.x, 16000 blok dengan 4000 # gandakan indeks
mul.u64
%r2, %tid.x, 64 utas dengan 16 float #
add.u64
%r1, %r1, %r2 tambahkan produk
Bab 4 Solusi ÿ 37
ld.param.u64
%r2, [tipL] # muat alamat basis tipL # tambahkan
add.u64
%r1,%r2,%r2 basis ke offset
add.u64
%r2, %ctaid.x,1 %r2, # hitung alamat tiPR: # gandakan indeks
mul.u64
%r2, 16000 %r3, blok dengan 4000 # gandakan
mul.u64
%tid.x, 64 %r2, %r2, indeks utas dengan 16 float # tambahkan produk #
add.u64
%r3 %r3, [tipR] muat alamat
ld.param.u64
%r2,%r2,%r3 basis tipL # tambahkan basis ke offset
add.u64
# hitung alamat clP: # gandakan indeks

mul.u64
%r3, %r3, 24000 blok dengan 4000 # gandakan
mul.u64
%r4, %tid.x, 16 %r3, indeks utas dengan 4 pelampung # tambahkan produk
%r3, %r4 %r4, # muat
tambahkan.u64
[tipR] alamat basis tipL # tambahkan basis
ld.param.u64 tambahkan.u6%4 r3,%r3,%r4 ke offset
ld.global.f32
%f1,[%r1] # memuat tiPL[0]
ld.global.f32
…
%f2,[%r1+4] # memuat tiPL[1]
ld.global.f32
%f16,[%r1+60] # memuat tiPL[15]
ld.global.f32
%f17,[%r2] # memuat tiPR[0]
ld.global.f32
…
%f18,[%r2+4] # memuat tiPR[1]
ld.global.f32
%f32,[%r1+60] # memuat tiPR[15] #
ld.shared.f32
%f33,[clL_s] memuat clL
ld.shared.f32
ld.shared.f32 %f34,[clL_s+4]
%f37,[clR_s] # memuat clR
ld.shared.f32
ld.shared.f32 %f38,[clR_s +4]
ld.shared.f32 %f39,[clR_s+8]
%f40,[clR_s+12]
mul.f32
mul.f32 %f1,%f1,%f33 # ekspresi pertama
mul.f32 %f2,%f2,%f34
mul.f32 %f3,%f3,%f35
add.f32 %f4,%f4,% f36
add.f32 %f1,%f1,%f2
add.f32 %f1,%f1,%f3
mul.f32 %f1,%f1,%f4
mul.f32 %f17,%f17,%f37
mul.f32 %f18,%f18,%f38
mul.f32 %f19,%f19,%f39
add.f32 % f20,%f20,%f40
add.f32 %f17,%f17,%f18
add.f32 %f17,%f17,%f19
%f17,%f17,%f20
st.global.f32
[%r3],%f17 # menyimpan hasil
mul.f32
%f5,%f5,%f33 # ekspresi kedua
mul.f32
%f6,%f6,%f34
mul.f32
%f7,%f7,%f35
mul.f32
%f8,%f8,%f36
add.f32
%f5,%f5,%f6
add.f32
%f5,%f5,%f7
add.f32
%f5 ,%f5,%f8
mul.f32
%f21,%f21,%f37
mul.f32
%f22,%f22,%f38
mul.f32
%f23,%f23,%f39
mul.f32
%f24,%f24,%f40
add.f32
%f21,%f21,%f22
add.f32
%f21,% f21,%f23
add.f32
%f21,%f21,%f24
st.global.f32
[%r3+4],%f21 # menyimpan hasil #
mul.f32
%f9,%f9,%f33 ekspresi ketiga
mul.f32
%f10,%f10,%f34
mul.f32
%f11,%11,%f35
mul.f32
%f12,%f12 ,%f36
add.f32
%f9,%f9,%f10
add.f32
%f9,%f9,%f11
add.f32
mul.f32 %f9,%f9,%f12
mul.f32 %f25,%f25,%f37
mul.f32 %f26,%f26,%f38
mul.f32 %f27,%f27,% f39
add.f32 %f28,%f28,%f40
add.f32 %f25,%f26,%f22
add.f32 %f25,%f27,%f23
%f25,%f28,%f24
st.global.f32
[%r3+8],%f25 # menyimpan hasil #
mul.f32
mul.f32 %f13,%f13,%f33 ekspresi keempat
mul.f32 %f14,%f14,%f34
mul.f32 %f15,%f15,%f35
add.f32 %f16,%f16,%f36
add.f32 %f13,%f14,%f6
add.f32 %f13,%f15,%f7
mul.f32 %f13,%f16,%f8
mul.f32 %f29 ,%f29,%f37
mul.f32 %f30,%f30,%f38
mul.f32 %f31,%f31,%f39
add.f32 %f32,%f32,%f40
add.f32 %f29,%f29,%f30
add.f32 %f29,%f29,%f31
st.global.f32 %f29,% f29,%f32

[%r3+12],%f29 # menyimpan hasil

Bab 4 Solusi ÿ 39
4.8 Ini akan bekerja dengan baik, karena tidak ada divergensi cabang, semua referensi memori
digabungkan, dan ada 500 utas yang tersebar di 6 blok (total 3000 utas), yang menyediakan
banyak instruksi untuk menyembunyikan latensi memori.
Latihan
4.9 sebuah. Kode ini membaca empat pelampung dan menulis dua pelampung untuk setiap enam pelampung, jadi
intensitas aritmatika = 6/6 = 1.
B. Asumsikan MVL = 64:
li
li $VL,44 # melakukan 44 operasi pertama $r1,0 #
menginisialisasi indeks $v1,a_re+$r1 #
loop: lv lv
memuat a_re $v3,b_re+$r1 #
mulvv.s memuat b_re $v5,$v1,$v3 #
lv a+re*b_re $ v2,a_im+$r1 # muat
a_im $v4,b_im+$r1 # muat b_im
lv
mulvv.s $v6,$v2,$v4 # a+im*b_im
subvv.s $v5,$v5,$v6 # a+re*b_re - a+im*
sv b_im $v5,c_re+$r1 # toko c_re $v5,$v1,$v4 #
mulvv.s a+re*b_im $v6,$v2,$v3 # a+im*b_re
mulvv.s $v5,$v5,$v6 # a+re *b_im +
addvv.s a+im*b_re $v5,c_im+$r1 # simpan
sv c_im $r1,0,else # periksa apakah iterasi pertama
$r1,$r1,#44 # iterasi pertama,
baiklah
kenaikan sebesar
j loop
44 # menjamin iterasi berikutnya
lain: addi
$r1,$r1,#256 # bukan iterasi pertama, kenaikan
sebesar 256
lewati: blt
$r1,1200,loop # iterasi berikutnya?
C.
1. mulvv.s
lv # a_re * b_re (anggap sudah # dimuat),
muat a_im mulvv.s # muat
2. lv b_im, a_im*b_im # kurangi dan simpan c
3. subvv.s sv _re # a_re*b_im, muat vektor a_re
4. mulvv.s lv berikutnya # a_im*b_re, muat vektor b_re
5. mulvv.s lv berikutnya # tambahkan dan toko c_im
6. addvv.s sv
6 lonceng
D. total siklus per iterasi =

6 lonceng × 64 elemen + 15 siklus (muat/simpan) × 6 + 8 siklus (kalikan) × 4 + 5 siklus
(tambah/kurangi) × 2 = 516 siklus
per hasil = 516/128 = 4
e.
1. mulvv.s 2.
# a_re*b_re #
mulvv.s 3. subvv.s
a_im*b_im #
sv 4. mulvv.s 5.
kurangi dan simpan c_re #
mulvv.s lv 6.
a_re*b_im #
addvv.s sv lv lv lv
a_im*b_re, muat a_re berikutnya #
tambahkan, simpan c_im, muat b_re berikutnya,a_im,b_im
Siklus yang sama per hasil seperti pada bagian c. Menambahkan unit beban/penyimpanan tambahan tidak
meningkatkan kinerja.
4.10 Prosesor vektor memerlukan:

ÿ (200 MB + 100 MB)/(30 GB/dtk) = 10 md untuk akses memori vektor +
ÿ 400 ms untuk eksekusi skalar.
Dengan asumsi perhitungan vektor dapat tumpang tindih dengan akses memori, total waktu =
410 ms.
Sistem hybrid memerlukan: ÿ

(200 MB + 100 MB)/(150 GB/dtk) = 2 ms untuk akses memori vektor +
ÿ 400 ms untuk eksekusi skalar +
ÿ (200 MB + 100 MB)/(10 GB/dtk) = 30 md untuk I/O host Bahkan
jika I/O host dapat tumpang tindih dengan eksekusi GPU, GPU akan memerlukan 430 md dan
karenanya akan mencapai kinerja yang lebih rendah daripada tuan rumah.
4.11 sebuah. for (i=0;i<32;i+=2) titik[i] = titik[i]+titik[i+1]; for (i=0;i<16;i+=4)
titik[i] = titik[i]+titik[i+2]; for (i=0;i<8;i+=8) titik[i] = titik[i]
+titik[i+4]; for (i=0;i<4;i+=16) titik[i] = titik[i]+titik[i+8]; for
(i=0;i<2;i+=32) titik[i] = titik[i]+titik[i+16];
titik[0]=titik[0]+titik[32];
B. li
$VL,4
addvv.s $v0(0),$v0(4)
addvv.s $v0(8),$v0(12)
addvv.s $v0(16),$v0(20)
addvv.s $v0(24),$v0(28)
addvv.s $v0 (32),$v0(36)
addvv.s $v0(40),$v0(44)
addvv.s $v0(48),$v0(52)
addvv.s $v0(56),$v0(60)
Bab 4 Solusi ÿ 41
C. untuk (unsigned int s= blockDim.x/2;s>0;s/=2) { if (tid<s)

sdata[tid]=sdata[tid]+sdata[tid+s]; syncthreads();
4.12 sebuah. Membaca 40 byte dan menulis 4 byte untuk setiap 8 FLOPS, jadi 8/44 FLOPS/byte.
B. Kode ini melakukan referensi tidak langsung melalui array Ca dan Cb, karena keduanya
diindeks menggunakan konten array IDx, yang hanya dapat dilakukan saat runtime. Meskipun
ini memperumit implementasi SIMD, masih mungkin untuk melakukan jenis pengindeksan
menggunakan instruksi beban tipe-kumpul. Loop paling dalam (berulang pada z) dapat
divektorisasi: nilai untuk Ex, dH1, dH2, Ca, dan Cb dapat dioperasikan
sebagai register atau vektor SIMD. Jadi kode ini dapat menerima SIMD dan eksekusi vektor.
C. Memiliki intensitas aritmatika 0,18, jika prosesor memiliki floating point puncak sepanjang
> (30 GB/s) × (0,18 FLOPs/byte) = 5,4 GFLOPs/s, maka kode ini kemungkinan besar terikat
memori, kecuali jika berfungsi set pas di dalam cache prosesor.
D. Intensitas aritmatika presisi tunggal sesuai dengan tepi atap

adalah 85/4 = 21,25 FLOPS/byte.
4.13 sebuah. 1,5 GHz × ,80 × ,85 × 0,70 × 10 inti × 32/4 = 57,12 GFLOPs/s
B. Pilihan 1:
1,5 GHz × ,80 × ,85 × ,70 × 10 inti × 32/2 = 114,24 GFLOPs/dtk (percepatan =
114,24/57,12 = 2)
Opsi 2: 1,5
GHz × ,80 × ,85 × ,70 × 15 core × 32/4 = 85,68 GFLOPs/s (percepatan = 85,68/57,12 = 1,5)
Opsi 3: 1,5
GHz × ,80 × ,95 × ,70 × 10 inti × 32/4 = 63,84 GFLOPs/dtk (percepatan = 63,84/57,12 = 1,11)
Opsi 3 adalah yang terbaik.
4.14 sebuah. Menggunakan tes GCD, sebuah dependensi muncul jika GCD (2,4) harus membagi 5 – 4. Dalam
kasus ini, dependensi loop-carried memang ada.
B. Ketergantungan keluaran
S1 dan S3 menyebabkan melalui A[i]
Anti-ketergantungan
S4 dan S3 menyebabkan anti-ketergantungan melalui C[i]

Kode yang ditulis ulang
untuk (i=0;i<100;i++) {
T[i] = A[i] * B[i]; /* S1
*/ B[i] = T[i] + c; /* S2
*/
A1[i] = C[i] * c; /* S3 */
C1[i] = D[i] * A1[i]; /* S4 */}

Ketergantungan sejati S4
dan S3 melalui A[i] S2
dan S1 sampai T[i]
C. Ada anti-ketergantungan antara iterasi i dan i+1 untuk array B. Ini bisa
dihindari dengan mengganti nama array B di S2.
4.15 sebuah. Divergensi cabang: menyebabkan jalur SIMD ditutup saat utas mengikuti jalur kontrol yang
berbeda b. Menutupi
latensi memori: cukup banyak utas aktif yang dapat menyembunyikan latensi memori dan
meningkatkan tingkat masalah instruksi
C. Referensi memori off-chip gabungan: akses memori harus diatur secara berurutan dalam grup
utas SIMD
D. Penggunaan memori on-chip: referensi memori dengan lokalitas harus memanfaatkan memori
on-chip, referensi ke memori on-chip dalam grup utas SIMD harus diatur untuk menghindari
konflik bank
4.16 GPU ini memiliki throughput puncak 1,5 × 16 × 16 = 384 GFLOPS/dtk throughput presisi tunggal.
Namun, dengan asumsi setiap operasi presisi tunggal memerlukan dua operan empat byte dan
menghasilkan satu hasil empat byte, mempertahankan throughput ini (dengan asumsi tidak ada
lokalitas temporal) akan membutuhkan bandwidth memori 12 byte/FLOP × 384 GFLOPs/s = 4,6
TB/s. Dengan demikian, throughput ini tidak berkelanjutan, namun masih dapat dicapai dalam
ledakan singkat saat menggunakan memori on-chip.
4.17 Kode referensi untuk latihan pemrograman:
#include <stdio.h>
#include <stdlib.h> #include
<sys/time.h> #include <cuda.h>
global void life (unsigned char *d_board, iterasi int) { int

i,baris,kolom,baris,kolom;
status karakter yang tidak ditandatangani,
tetangga; baris = blockIdx.y * blockDim.y + threadIdx.y; col =

blockIdx.x * blockDim.x + threadIdx.x; baris = gridDim.y *
blockDim.y; cols = gridDim.x * blokDim.x;
status = d_board[(baris)*kolom+(kolom)];
untuk (i=0;i<iterasi;i++) { tetangga=0; if (baris!=0)

{ if (col!=0) if (d_board[(baris-1)*cols+
(col-1)]==1)
tetangga++; if
(d_board[(baris-1)*cols+(col)]==1) tetangga++; if (col!=(cols-1)) if (d_board[(baris-1)*cols+
(col+1)]==1) tetangga++; } if (col!=0) if (d_board[(row)*cols+(col-1)]==1)
tetangga++;

Bab 4 Solusi ÿ 43
if (col!=(cols-1)) if (d_board[(row)*cols+(col+1)]==1) tetangga++; if (baris!

=(baris-1)) {
if (col!=0) if (d_board[(baris+1)*cols+(col-1)]==1) tetangga++; if
(d_board[(baris+1)*cols+(col)]==1) tetangga++; if (col!
=(cols-1)) if (d_board[(baris+1)*cols+(col+1)]==1) tetangga++;
} if (tetangga<2) status = 0;
lain jika (tetangga==3) status = 1;
lain jika (tetangga>3) status = 0;
syncthreads(); d_board[(baris)*kolom+
(kolom)]=status;
}
} int utama ()
{ dim3
gDim,bDim; unsigned char
*h_board,*d_board; int i,iterasi=100;
bDim.y=16;
bDim.x=32;
bDim.z=1;
gDim.y=16;
gDim.x=8; gDim.z=1;
h_board=(unsigned char *)malloc(sizeof(unsigned char)*4096*4096);
cudaMalloc((void **)&d_board,sizeof(unsigned char)*4096*4096);
srand(56);
untuk (i=0;i<4096*4096;i++) h_board[i]=rand()%2; cudaMemcpy(d_board,h_board,sizeof(unsigned
char)*4096*4096,cudaMemcpyHostToDevice); hidup <<<gDim,bDim>>> (d_board,iterasi);
cudaMemcpy(h_board,d_board,sizeof(unsigned char)*4096*4096,cudaMemcpyDeviceToHost);
gratis(h_papan); cudaFree(d_board);
}

Bab 5 Solusi
Studi Kasus 1: Multiprosesor Multicore Chip Tunggal
5.1
A. P0: baca 120 P0.B0: (S, 120, 0020) mengembalikan
B. P0: tulis 120 80 0020 P0.B0: (M, 120, 0080)
P3.B0: (I, 120, 0020)

C. P3: tulis 120 80 P3.B0: (L, 120, 0080)
D. P1: baca 110 P1.B2: (S, 110, 0010) mengembalikan
e. P0 : tulis 108 48 0010 P0.B1: (M, 108, 0048)
P3.B1: (I, 108, 0008)

F. P0 : tulis 130 78 P0.B2: (M, 130, 0078)
M: 110 0030 (tulis kembali ke memori)
G. P3: tulis 130 78 P3.B2: (L, 130, 0078) 5.2
a. P0: baca 120, Baca rindu, puas dengan memori
P0: baca 128, Baca rindu, puas dengan cache P1
P0: baca 130, baca rindu, puas memori, writeback 110
Implementasi 1: 100 + 40 + 10 + 100 + 10 = 260 siklus kios
Implementasi 2: 100 + 130 + 10 + 100 + 10 = 350 siklus kios
B. P0: baca 100, Baca rindu, puas dengan memori P0:
tulis 108 48, Tulis hit, kirim tidak valid
P0: tulis 130 78, Tulis rindu, puas ingatan, tulis kembali 110
Implementasi 1: 100 + 15 + 10 + 100 = 225 siklus kios
C. P1: baca 120, Baca rindu, puas dengan memori P1:
baca 128, Baca tekan
P1: baca 130, Baca rindu, puas dengan memori
Implementasi 1: 100 + 0 + 100 = 200 siklus kios
Implementasi 2: 100 + 0 + 100 = 200 siklus kios
D. P1: baca 100, Baca rindu, puas dengan memori
P1: tulis 108 48, Tulis rindu, puas ingatan, tulis kembali 128 P1:
tulis 130 78, Tulis rindu, puas dengan ingatan Implementasi 1:
100 + 100 + 10 + 100 = 310 siklus kios
5.3 Lihat Gambar S.28

Bab 5 Solusi ÿ 45
Tulis rindu atau batalkan

untuk blok ini
Tidak sah CPU membaca Bersama
Tempat baca rindu di bus
CPU membaca hit
tulis CPU
Tulis rindu untuk

blok ini
Baca rindu
Diubah blok tulis kembali; batalkan Dimiliki

akses memori
tulis CPU
Tempatkan validasi di bus
Pukulan penulisan CPU CPU membaca hit

CPU membaca hit
Gambar S.28 Diagram protokol.
5.4 (Menampilkan hasil implementasi 1)
A. P1: baca 110, Baca rindu, cache P0
P3: baca 110, Baca rindu, MSI memenuhi memori, MOSI memenuhi cache P0
P0: baca 110, Baca tekan
MSI: 40 + 10 + 100 + 0 = 150 siklus kios
MOSI: 40 + 10 + 40 + 10 + 0 = 100 siklus kios
B. P1: baca 120, Baca rindu, puas di memori P3:
baca 120, Baca hit
P0: baca 120, Baca rindu, puas di memori Kedua
protokol: 100 + 0 + 100 = 200 siklus kios
C. P0: tulis 120 80, Tulis miss, batalkan P3
P3: baca 120, Baca rindu, cache P0 P0:
baca 120, Baca tekan
Kedua protokol: 100 + 40 + 10 + 0 = 150 siklus kios

D. P0: tulis 108 88, Kirim batal, batalkan P3
P3: baca 108, Baca rindu, cache P0

P0: tulis 108 98, Kirim batal, batalkan P3
Kedua protokol: 15 + 40 + 10 + 15 = 80 siklus kios
5.5 Lihat Gambar S.29
Tulis rindu atau batalkan untuk blok

ini
Tidak sah CPU membaca, blok bersama lainnya Bersama
Tempat baca rindu di bus
CPU membaca hit
Diubah Kecuali
Pukulan penulisan CPU

CPU membaca hit
Gambar S.29 Diagram untuk protokol MESI.
5.6 sebuah. p0: baca 100, Baca rindu, puas di memori, tidak ada pembagi MSI: S, MESI: E p0: tulis
100 40, MSI: kirim tidak valid, MESI: transisi senyap dari E ke M
MSI: 100 + 15 = 115 siklus kios
MESI: 100 + 0 = 100 siklus kios

B. p0: baca 120, Baca rindu, puas di memori, berbagi keduanya ke S p0:
tulis 120 60, Keduanya mengirim tidak valid

Keduanya: 100 + 15 = 115 siklus kios
C. p0: baca 100, Baca rindu, puas di memori, tidak ada pembagi MSI: S, MESI: E p0:
baca 120, Baca rindu, memori, ganti diam-diam 120 dari S atau E Keduanya: 100 +
100 = 200 siklus kios, penggantian senyap dari E

Bab 5 Solusi ÿ 47
D. p0: baca 100, Baca rindu, puas di memori, tidak ada pembagi MSI: S, MESI: E p1:
tulis 100 60, Tulis rindu, puas di memori terlepas dari protokol
Keduanya: 100 + 100 = 200 siklus kios, jangan berikan data dalam status E (beberapa protokol melakukannya)
e. p0: baca 100, Baca rindu, puas di memori, tidak ada pembagi MSI: S, MESI: E
p0: tulis 100 60, MSI: kirim tidak valid, MESI: transisi senyap dari E ke M p1: tulis 100 40, Tulis
rindu, cache P0, tulis kembali data ke memori
MSI: 100 + 15 + 40 + 10 = 165 siklus kios
MESI: 100 + 0 + 40 + 10 = 150 siklus kios
5.7 sebuah. Asumsikan prosesor mendapatkan kunci secara berurutan. P0 akan memperolehnya terlebih dahulu,
mengeluarkan 100 siklus kios untuk mengambil blok dari memori. P1 dan P3 akan terhenti sampai bagian
kritis P0 berakhir (ping-pong blok bolak-balik) 1000 siklus kemudian. P0 akan terhenti selama (sekitar) 40
siklus saat mengambil blok untuk membatalkannya; maka P1 membutuhkan 40 siklus untuk
mendapatkannya. Bagian kritis P1 adalah 1000 siklus, ditambah 40 untuk menangani kesalahan penulisan
saat rilis. Akhirnya, P3 mengambil blok tersebut untuk 40 siklus terakhir. Jadi, P0 terhenti selama 100 siklus
untuk memperoleh, 10 untuk memberikannya ke P1, 40 untuk melepaskan kunci, dan 10 terakhir untuk
menyerahkannya ke P1, dengan total 160 siklus terhenti. P1 pada dasarnya berhenti sampai P0 melepaskan
kunci, yang akan menjadi 100 + 1000 + 10 + 40 = 1150 siklus, ditambah 40 untuk mendapatkan kunci, 10
untuk
memberikannya ke P3, 40 untuk mendapatkannya kembali untuk melepaskan kunci, dan final 10 untuk meng
Ini adalah total 1250 siklus kios. P3 berhenti sampai P1 menyerahkan kunci yang dilepaskan, yaitu
1150 + 40 + 10 + 1000 + 40 = 2240 siklus. Akhirnya, P3 mendapatkan kunci 40 siklus kemudian,
sehingga terhenti sebanyak 2280 siklus.
B. Spin lock yang dioptimalkan akan memiliki siklus stall yang jauh lebih sedikit daripada spin lock biasa
karena menghabiskan sebagian besar bagian kritis dalam putaran spin (yang meskipun tidak berguna,
tidak didefinisikan sebagai siklus stall). Dengan menggunakan analisis di bawah ini untuk transaksi
interkoneksi, siklus kios akan menjadi 3 kesalahan baca memori (300), 1 peningkatan (15) dan 1
kesalahan penulisan ke cache (40 + 10) dan 1 kesalahan penulisan ke memori (100), 1 baca cache miss
to cache (40 + 10), 1 write miss to memory (100), 1 read miss to cache dan 1 read miss to memory (40 +
10 + 100), diikuti dengan upgrade (15) dan write miss ke cache (40 + 10), dan terakhir miss tulis ke
cache (40 + 10) diikuti dengan miss baca ke cache (40 + 10) dan upgrade (15). Jadi total sekitar 945
siklus.
C. Sekitar 31 transaksi interkoneksi. Prosesor pertama yang memenangkan arbitrasi untuk interkoneksi
mendapat blok pada percobaan pertamanya (1); dua lainnya ping-pong blok bolak- balik selama bagian
kritis. Karena latensi adalah 40 siklus, ini akan terjadi sekitar 25 kali (25). Prosesor pertama melakukan
penulisan untuk melepaskan kunci, menyebabkan transaksi bus lain (1), dan prosesor kedua melakukan
transaksi untuk melakukan pengujian dan pengaturannya (1). Prosesor terakhir mendapatkan blok (1) dan
memutarnya hingga prosesor kedua melepaskannya (1). Akhirnya prosesor terakhir mengambil blok (1).

D. Sekitar 15 transaksi interkoneksi. Asumsikan prosesor mendapatkan kunci secara berurutan. Ketiga prosesor
melakukan tes, menyebabkan read miss, kemudian tes dan set, menyebabkan prosesor pertama meng-upgrade
dan dua lainnya menulis miss (6). Yang kalah duduk di loop pengujian, dan salah satu dari mereka harus
mendapatkan kembali blok yang dibagikan terlebih dahulu (1). Saat prosesor pertama melepaskan kunci,
dibutuhkan kesalahan penulisan (1) dan kemudian kedua yang kalah melakukan kesalahan pembacaan (2).
Keduanya memiliki tes mereka berhasil, sehingga pemenang baru melakukan upgrade dan pecundang baru
mengambil kesalahan penulisan (2). Yang kalah memutar blok eksklusif sampai pemenang melepaskan kunci
(1). Yang kalah pertama- tama menguji blok (1) dan kemudian menguji-dan-menyetelnya, yang membutuhkan
pemutakhiran (1).
5.8 Latensi dalam implementasi 1 dari Gambar 5.36 digunakan.
A. P0: tulis 110 80 Hit di cache P0, tidak ada siklus kios untuk TSO atau SC Hit di cache P0, tidak ada
P0: baca 108

siklus kios untuk TSO atau SC b. P0: tulis 100 80 Nona, TSO
memenuhi tulis di buffer tulis (0 siklus kios)

SC harus menunggu hingga menerima data (100 siklus kios)
P0: baca 108
Hit, tetapi harus menunggu operasi sebelumnya: TSO = 0, SC = 100
C. P0: tulis 110 80 Hit di cache P0, tidak ada siklus kios untuk TSO atau SC
P0: tulis 100 90 Nona, TSO memenuhi tulis di buffer tulis (0 siklus kios) SC harus menunggu
hingga menerima data (100 siklus kios)
D. P0: tulis 100 80 Nona, TSO memenuhi tulis di buffer tulis (0 kios
siklus) SC harus menunggu sampai menerima data (100 siklus kios)
P0: tulis 110 90 Hit, tetapi harus menunggu operasi sebelumnya:

TSO = 0, SC = 100
Studi Kasus 2: Koherensi Berbasis Direktori Sederhana
5.9 sebuah. P0,0 : baca 100 b.

Hit L1 mengembalikan 0x0010, status tidak berubah (M)
P0,0: baca 128
L1 miss dan L2 miss akan menggantikan B1 di L1 dan B1 di L2 yang
beralamat 108.
L1 akan memiliki 128 di B1 (dibagi), L2 juga akan memilikinya

(DS, P0,0)
Entri direktori memori untuk 108 akan menjadi <DS, C1>
Entri direktori memori untuk 128 akan menjadi <DS, C0> c, d,
…, h: ikuti pendekatan yang sama

Bab 5 Solusi ÿ 49
5.10 sebuah. P0,0: tulis 100 80, Tulis tekan hanya dilihat oleh P0,0
B. P0,0: tulis 108 88, Tulis “upgrade” yang diterima P0,0; batal diterima
oleh P3,1
C. P0,0: tulis 118 90, Rindu tulis diterima P0,0; batal diterima oleh P1,0 d. P1,0: tulis 128 98,
Tulis rindu diterima P1,0.
5.11 a. Lihat Gambar S.30 dan S.31
CPU membaca rindu

Baca rindu
Batalkan
Tidak sah CPU membaca Bersama
Kirim pesan yang telah dibaca
CPU membaca hit
tulis CPU
CPU membaca rindu CPU menulis rindu Menulis

Baca rindu
CPU menulis rindu Menulis data kembali
Menulis rindu
Baca rindu
Diubah Kirim data Dimiliki
tulis CPU
Kirim pesan yang tidak valid

CPU membaca hit
Gambar S.30 Status cache.
5.12 Status Eksklusif (E) menggabungkan properti Modifikasi (M) dan Dibagi (S).
Keadaan E memungkinkan peningkatan diam ke M, memungkinkan prosesor untuk menulis blok tanpa
mengkomunikasikan fakta ini ke memori. Ini juga memungkinkan downgrade senyap ke I, memungkinkan
prosesor membuang salinannya dengan memori pemberitahuan. Memori harus memiliki cara untuk
menyimpulkan salah satu dari transisi ini. Dalam sistem berbasis direktori, ini biasanya dilakukan dengan
membuat direktori berasumsi bahwa node berada dalam status M dan meneruskan semua kesalahan ke
node tersebut. Jika sebuah node secara diam-diam diturunkan ke I, maka ia mengirimkan NACK
(Pengakuan Negatif) kembali ke direktori, yang kemudian menyimpulkan bahwa penurunan telah terjadi.
Namun, ini menghasilkan perlombaan dengan pesan lain, yang dapat menyebabkan masalah lain.

Baca rindu
Tidak sah
jawaban nilai data, Pembagi = {P} Bersama
Baca rindu
Balasan nilai data Pembagi = pembagi + {P}
Baca rindu
Mengambil
Baca rindu
Mengambil; Balasan nilai data Pembagi = pembagi + {P} Respon nilai data
Menulis rindu Pembagi = pembagi + {P}
Diubah Ambil tidak valid Dimiliki
Respon nilai data Pembagi = {P}
Menulis rindu
Ambil tidak valid
Respon nilai data Pembagi = {P}
Gambar S.31 Direktori menyatakan.
Studi Kasus 3: Protokol Direktori Lanjutan

5.13 sebuah. P0,0: baca 100 Baca hit
B. P0,0: baca 120 Nona, akan mengganti data yang dimodifikasi (B0) dan mendapatkan baris baru dalam
status bersama
P0,0: M MIA I ISDS Dir: DM {P0,0}DI {}
C. P0,0: tulis 120 80 Miss akan mengganti data yang dimodifikasi (B0) dan mendapatkan baris baru
dalam keadaan termodifikasi
P0,0: M MIA I IMAD IMA

M P3,1: SI
Dir: DS {P3,0} DM {P0,0}
d, e, f: langkah-langkah yang mirip dengan bagian a, b, dan c
5.14 sebuah. P0,0: baca 120

Nona, akan mengganti data yang dimodifikasi (B0) dan mendapatkan baris baru dalam
status bersama
P0,0: M MIA I ISD S

Bab 5 Solusi ÿ 51
P1,0: baca 120

status bersama
P1,0: M MIA I ISD S
Dir: DS {P3,0} DS {P3,0; P0,0} DS {P3,0;

P0,0; P1,0}
B. P0,0: baca 120
status bersama
P0,0: M MIA I ISD S
P1,0: tulis 120 80 Miss akan mengganti data yang dimodifikasi (B0) dan mendapatkan baris baru
dalam keadaan termodifikasi
P1,0: M MIA I IMAD IMA M
P3,1: SI
Dir: DS {P3,1} DS {P3,0; P1,0} DM {P1,0}
c, d, e: langkah-langkah yang mirip dengan bagian a dan b
5.15 sebuah. P0,0: baca 100

Baca hit, 1 siklus
B. P0,0: baca 120
Baca Nona, menyebabkan penggantian blok yang dimodifikasi dan dipenuhi
dalam memori dan menimbulkan 4 penyeberangan
chip (lihat yang digarisbawahi)
Latensi untuk P0,0:
Lsend_data + Ldata_msg + Lwrite_memory + Linv +
L_ack + Lreq_msg + Lsend_msg + Lreq_msg +
Lread_memory + Ldata_msg + Lrcv_data + 4 × latensi
penyeberangan chip = 20 + 30 + 20 + 1 + 4 +
15 + 6 + 15 + 100 + 30 + 15 + 4 × 20 = 336
c, d, e: ikuti langkah yang sama seperti a dan b
5.16 Semua protokol harus memastikan kemajuan ke depan, bahkan di bawah pola akses memori terburuk.
Sangat penting bahwa implementasi protokol menjamin (setidaknya dengan argumen probabilistik)
bahwa prosesor akan dapat melakukan setidaknya satu operasi memori setiap kali menyelesaikan
cache miss. Jika tidak, kelaparan mungkin terjadi. Pertimbangkan kode kunci putaran sederhana:
tas:
Kunci DADDUI R2, R0,
#1:
EXCH R2, 0(R1)
BNEZ R2, terkunci
Jika semua prosesor berputar pada loop yang sama, mereka semua akan berulang kali
mengeluarkan pesan GetM. Jika prosesor tidak dijamin dapat melakukan setidaknya satu instruksi,
maka masing-masing dapat mencuri blok dari yang lain berulang kali. Dalam kasus terburuk, tidak
ada prosesor yang berhasil melakukan pertukaran.

5.17 sebuah. Status MSA pada dasarnya adalah "transient O" karena memungkinkan prosesor membaca data
dan akan merespons permintaan GetShared dan GetModified dari prosesor lain. Itu sementara,
dan bukan status O nyata, karena memori akan mengirim PutM_Ack dan bertanggung jawab
atas permintaan di masa mendatang.
B. Lihat Gambar S.32 dan S.33
Ganti ment Diteruskan_ Diteruskan_ PutM_

Status Baca Menulis INV Mendapat DapatkanM Ack Data ACK terakhir
SAYA mengirim mengirim kesalahan mengirim kesalahan kesalahan kesalahan kesalahan kesalahan
GetS/IS DapatkanM/IM Ack/I
S lakukan Baca kirim SAYA mengirim kesalahan kesalahan kesalahan kesalahan kesalahan
DapatkanM/IM Ack/I
HAI lakukan Baca kirim mengirim kesalahan kirim Data kirim Data/I kesalahan — —
GetM/OM Put M/OI
M lakukan Baca lakukan Tulis

mengirim kesalahan kirim Data/O kirim Data/I kesalahan kesalahan kesalahan
Put M/MI
ADALAH z z z mengirim kesalahan kesalahan kesalahan simpan Data, kesalahan
Ack/ISI lakukan Baca/S
ISI z z z kesalahan kirim Ack kesalahan kesalahan simpan Data, kesalahan
lakukan Baca/I
AKU z z z kirim Ack IMO IMIA kesalahan simpan Data lakukan Write/M
I MI z z z kesalahan kesalahan kesalahan kesalahan simpan Data lakukan Tulis, kirim

Data/I
IMO z z z mengirim — IMOI kesalahan simpan Data lakukan Tulis, kirim

Ack/IMI Data/O
IMOI z z z kesalahan kesalahan kesalahan kesalahan simpan Data lakukan Tulis, kirim
Data/I
OI z z z kesalahan kirim Data kirim Data /SAYA kesalahan kesalahan
MI z z z kesalahan kirim Data kirim Data /SAYA kesalahan kesalahan
OM z
z z kesalahan kirim Data kesalahan kirim Data/IM simpan Data lakukan Write/M
Gambar S.32 Transisi pengontrol cache protokol direktori.
Pengganti (pemilik) INV

Negara Membaca Menulis (bukan pemilik)
DI kirim Data, kirim Data, hapus pembagi, kesalahan kirim PutM_Ack

tambahkan ke sharers/DS tetapkan pemilik/DM
DS kirim Data, kirim INV ke pembagi, hapus kesalahan kirim PutM_Ack

tambahkan ke pembagi pembagi, tetapkan pemilik, kirim
Data/DM
MELAKUKAN
teruskan GetS, teruskan GetM, kirim INV ke pembagi, kirim Data, kirim kirim PutM_Ack
tambahkan ke pembagi hapus pembagi, tetapkan pemilik/ PutM_Ack/DS
DM
DM teruskan GetS, tambahkan ke teruskan GetM, kirim INV ke pembagi, kirim Data, kirim kirim PutM_Ack
pemohon dan pemilik ke hapus pembagi, tetapkan pemilik PutM_Ack/DI
pembagi/LAKUKAN
Gambar S.33 Transisi pengontrol direktori.

Bab 5 Solusi ÿ 53
5.18a. P1,0: baca 100
P3,1: tulis 100 90 Dalam
masalah ini, P0,1 dan P3,1 kehilangan dan mengirim permintaan yang berlomba ke direktori. Dengan
asumsi bahwa permintaan GetS P0,1 tiba lebih dulu, direktori akan meneruskan GetS P0,1 ke P0,0,
diikuti segera setelah itu oleh GetM P3,1. Jika jaringan mempertahankan urutan point-to-point, maka
P0,0 akan melihat permintaan dalam urutan yang benar dan protokol akan berfungsi seperti yang
diharapkan. Namun, jika permintaan yang di-ward datang tidak sesuai urutan, maka GetX akan
memaksa P0 untuk menyatakan I, menyebabkannya mendeteksi kesalahan saat GetS yang diteruskan
P1 tiba.
B. P1,0: baca 100
P0,0: ganti 100 GetS
P1,0 tiba di direktori dan diteruskan ke P0,0 sebelum pesan PutM P0,0 tiba di direktori dan
mengirimkan PutM_Ack. Namun, jika PutM_Ack tiba di P0,0 rusak (yaitu, sebelum GetS yang
diteruskan), maka ini akan menyebabkan P0,0 bertransisi ke keadaan I. Dalam hal ini, GetS yang
diteruskan akan diperlakukan sebagai kondisi kesalahan.
Latihan
5.19 Bentuk umum Hukum Amdahl adalah
Waktu eksekusi lama

Percepatan =
Waktu eksekusi baru
semua yang perlu dilakukan untuk menghitung rumus percepatan dalam kasus multiprosesor ini adalah
mendapatkan waktu eksekusi yang baru.
Latihan menyatakan bahwa untuk porsi waktu eksekusi awal yang dapat menggunakan prosesor ke-i
diberikan oleh F(i,p). Jika waktu Eksekusi kita biarkan menjadi 1, maka waktu relatif untuk aplikasi
pada p prosesor diberikan dengan menjumlahkan waktu yang diperlukan untuk setiap porsi waktu
eksekusi yang dapat dipercepat menggunakan prosesor i , di mana i berada di antara 1 dan p. Ini
menghasilkan
P f-i-(---)--,--
Waktu eksekusi baru =ÿ h--a--l
saya 1=
Saya
Mensubstitusi nilai Execution timenew ini ke dalam persamaan speedup menjadikan Hukum
Amdahl sebagai fungsi dari prosesor yang tersedia, hal.
5.20 suatu. (i) 64 prosesor disusun sebagai cincin: jumlah komunikasi terbesar hop =
32 biaya komunikasi = (100 + 10 × 32) ns = 420 ns.
(ii) 64 prosesor disusun sebagai kisi prosesor 8x8: jumlah lompatan komunikasi terbesar = 14
biaya komunikasi = (100 + 10 × 14) ns = 240 ns. (iii) 64 prosesor disusun sebagai
hypercube: jumlah hop terbesar = 6 (log2 64) biaya komunikasi = (100 + 10 × 6) ns = 160 ns.
B. IHK Dasar = 0,5 cpi
(i) 64 prosesor disusun sebagai cincin: CPI kasus terburuk = 0,5 + 0,2/100 × (420)
= 1,34 cpi
(ii) 64 prosesor disusun sebagai kisi prosesor 8x8: CPI kasus terburuk = 0,5 + 0,2/ 100 ×
(240) = 0,98 cpi
(iii) 64 prosesor disusun sebagai hypercube: Kasus terburuk CPI CPI = 0,5 + 0,2/ 100 ×
(160) = 0,82 cpi
CPI rata-rata dapat diperoleh dengan mengganti jumlah lompatan komunikasi

terbesar dalam perhitungan di atas dengan , rata-rata jumlah komunikasi lompatan hˆ .
Angka terakhir itu tergantung pada topologi dan aplikasinya. C.
Karena frekuensi CPU dan jumlah instruksi yang dieksekusi tidak berubah, jawabannya dapat
diperoleh dengan CPI untuk setiap topologi (kasus terburuk atau rata-rata) dengan CPI
dasar (tidak ada komunikasi jarak jauh).
5.21 Agar gambar tidak berantakan, protokol koherensi dibagi menjadi dua bagian seperti yang
dilakukan pada Gambar 5.6 dalam teks. Gambar S.34 menyajikan bagian CPU dari protokol
koherensi, dan Gambar S.35 menyajikan bagian bus dari protokol. Dalam kedua gambar ini,
busur menunjukkan transisi dan teks di sepanjang setiap busur menunjukkan stimulus (dalam
teks normal) dan aksi bus (dalam teks tebal) yang terjadi
selama transisi antar keadaan. Akhirnya, seperti teksnya, kami menganggap penulisan yang
salah ditangani sebagai kesalahan penulisan.
Gambar S.34 menampilkan perilaku transisi keadaan yang disebabkan oleh CPU itu sendiri.
Dalam kasus ini, penulisan ke blok baik dalam status tidak valid atau bersama menyebabkan kita
melakukan broadcast "write invalidate" untuk menghapus blok dari cache lain yang menyimpan
blok dan pindah ke status eksklusif. Kita dapat meninggalkan status eksklusif melalui invalidasi
dari prosesor lain (yang terjadi di sisi bus dari diagram status protokol koherensi), atau kesalahan
baca yang dihasilkan oleh CPU (yang terjadi saat blok data eksklusif dipindahkan dari cache oleh
blok kedua). Dalam status bersama, hanya penulisan oleh CPU atau pembatalan dari prosesor lain
yang dapat mengeluarkan kita dari status ini. Dalam kasus transisi yang disebabkan oleh kejadian
di luar CPU, diagram keadaan cukup sederhana, seperti yang ditunjukkan pada Gambar S.35.
Ketika prosesor lain menulis blok yang ada di cache kami, kami tanpa syarat membatalkan
blok yang sesuai di cache kami. Ini memastikan bahwa lain kali kami membaca data, kami
akan memuat nilai blok yang diperbarui dari memori. Juga, setiap kali bus melihat kesalahan
baca, ia harus mengubah status blok eksklusif menjadi dibagikan karena blok tersebut tidak
lagi eksklusif untuk satu cache.
Perubahan besar yang diperkenalkan dalam perpindahan dari write-back ke write- through cache
adalah penghapusan kebutuhan untuk mengakses blok kotor di cache prosesor lain. Akibatnya,
dalam protokol write-through, tidak perlu lagi menyediakan perangkat keras untuk memaksa
penulisan kembali pada akses baca atau membatalkan akses memori yang tertunda. Karena
memori diperbarui selama penulisan apa pun pada cache tulis, prosesor yang menghasilkan
kesalahan baca akan selalu mengambil informasi yang benar dari memori. Pada dasarnya, blok
cache yang valid tidak mungkin tidak koheren sehubungan dengan memori utama dalam sistem
dengan cache tulis.

Bab 5 Solusi ÿ 55
CPU membaca
Dibagikan
Tidak sah (hanya baca)
CPU
membaca
tulis CPU CPU membaca

Batalkan blok rindu
tulis CPU
Batalkan blok
Eksklusif
(baca/tulis)
CPU membaca hit atau write
Gambar S.34 Bagian CPU dari protokol koherensi cache sederhana untuk cache tulis.
Menulis rindu Dibagikan

Tidak sah
Batalkan blok (hanya baca)
Menulis rindu
Batalkan blok
Eksklusif
(baca/tulis) Baca rindu
Gambar S.35 Porsi bus dari protokol koherensi cache sederhana

untuk cache tulis.

5.22 Untuk menambah protokol pengintaian pada Gambar 5.7 dengan status Eksklusif Bersih, kami berasumsi
bahwa cache dapat membedakan kesalahan baca yang akan mengalokasikan blok yang ditujukan untuk status
Eksklusif Bersih dari kesalahan baca yang akan mengirimkan blok Bersama.
Tanpa diskusi lebih lanjut kami berasumsi bahwa ada beberapa mekanisme untuk melakukannya.
Tiga status pada Gambar 5.7 dan transisi di antara mereka tidak berubah, dengan pengecualian yang mungkin
untuk mengklarifikasi penggantian nama status Eksklusif (baca/tulis) menjadi Eksklusif Kotor (baca/tulis).
Status Eksklusif Bersih (hanya baca) yang baru harus ditambahkan ke diagram bersama dengan transisi berikut.
ÿ dari Eksklusif Bersih ke Eksklusif Bersih jika terjadi pembacaan CPU mengenai blok ini atau
pembacaan CPU gagal pada blok Eksklusif Kotor
ÿ dari Eksklusif Bersih ke Dibagi jika terjadi kesalahan pembacaan CPU di blok Bersama atau di blok
Eksklusif Bersih
ÿ dari Bersih Eksklusif untuk Dibagi dalam hal membaca ketinggalan di bus untuk ini
memblokir
ÿ dari Bersih Eksklusif ke Invalid dalam hal miss menulis di bus untuk ini
memblokir
ÿ dari Eksklusif Bersih ke Eksklusif Kotor jika CPU write hit di blok ini atau CPU write miss
ÿ dari Eksklusif Kotor ke Eksklusif Bersih jika CPU salah membaca a

Blok Eksklusif Kotor ÿ dari
Tidak Valid menjadi Eksklusif Bersih jika terjadi kesalahan pembacaan CPU pada Kotor Blok
eksklusif
ÿ dari Shared to Clean Exclusive dalam hal CPU membaca miss pada Dirty
Blok eksklusif
Beberapa transisi dari protokol asli harus diubah untuk mengakomodasi keberadaan negara Eksklusif Bersih.
Tiga transisi berikut adalah yang berubah.
ÿ dari Dirty Exclusive ke Shared, label berubah menjadi CPU read miss on a
Blok bersama
ÿ dari Invalid menjadi Shared, label berubah menjadi CPU miss pada blok Shared ÿ dari Shared
menjadi Shared, label transisi miss berubah menjadi CPU read miss on
blok bersama
5.23 Sebuah komplikasi yang jelas diperkenalkan dengan memberikan bit per kata yang valid adalah kebutuhan untuk
mencocokkan tidak hanya tag blok tetapi juga offset dalam blok saat mengintai bus. Ini mudah, melibatkan hanya
melihat beberapa bit lagi. Selain itu, bagaimanapun, cache harus diubah untuk mendukung write-back blok cache
parsial. Saat menulis kembali sebuah blok, hanya kata-kata yang valid yang harus ditulis ke memori karena isi kata-
kata yang tidak valid belum tentu koheren.

Bab 5 Solusi ÿ 57
dengan sistem. Akhirnya, mengingat bahwa mesin negara Gambar 5.7 diterapkan pada setiap blok
cache, harus ada cara untuk memungkinkan diagram ini berlaku ketika negara bisa berbeda dari
kata ke kata dalam blok. Cara termudah untuk melakukannya adalah dengan memberikan informasi
status gambar untuk setiap kata di blok. Melakukan hal itu akan membutuhkan lebih dari satu bit
yang valid per kata. Tanpa replikasi informasi negara, satu-satunya solusi adalah mengubah sedikit
protokol koherensi.
5.24 sebuah. Komponen eksekusi instruksi akan dipercepat secara signifikan karena eksekusi yang tidak
sesuai urutan dan beberapa masalah instruksi memungkinkan latensi komponen ini tumpang
tindih. Komponen akses cache juga akan dipercepat karena tumpang tindih dengan instruksi
lain, tetapi karena akses cache memakan waktu
lebih lama daripada latensi unit fungsional, mereka memerlukan lebih banyak instruksi untuk
dikeluarkan secara paralel untuk tumpang tindih seluruh latensinya. Jadi speedup untuk
komponen ini akan lebih rendah.
Komponen waktu akses memori juga akan ditingkatkan, tetapi percepatan di sini akan lebih
rendah dari dua kasus sebelumnya. Karena memori terdiri dari akses memori lokal dan jarak
jauh dan kemungkinan transfer cache ke cache lainnya, latensi operasi ini cenderung sangat
tinggi (100-an siklus prosesor). Jendela instruksi 64- entri dalam contoh ini sepertinya tidak
memungkinkan instruksi yang cukup untuk tumpang tindih dengan latensi yang begitu lama.
Namun, ada satu kasus ketika latensi besar dapat tumpang tindih: saat tersembunyi di bawah
operasi latensi panjang lainnya. Ini mengarah pada teknik yang disebut miss-clustering yang
telah menjadi subyek dari beberapa pengoptimalan kompiler.
Komponen kios lainnya umumnya akan ditingkatkan karena sebagian besar terdiri dari kios
sumber daya, salah prediksi cabang, dan sejenisnya. Komponen sinkronisasi jika ada tidak akan
banyak dipercepat.
B. Waktu kios memori dan waktu jeda instruksi yang hilang mendominasi eksekusi untuk OLTP,
lebih dari tolok ukur lainnya. Kedua komponen ini tidak ditangani dengan baik oleh eksekusi
out-of-order. Oleh karena itu, beban kerja OLTP memiliki kecepatan lebih rendah
dibandingkan tolok ukur lain dengan Sistem B.
5.25 Karena pembagian palsu terjadi ketika kedua ukuran objek data lebih kecil daripada perincian cakupan
bit valid blok cache dan lebih dari satu objek data disimpan dalam bingkai blok cache yang sama di
memori, ada dua cara untuk mencegah pembagian palsu . Mengubah ukuran blok cache atau jumlah
blok cache yang dicakup oleh bit valid yang diberikan adalah perubahan perangkat keras dan di luar
cakupan latihan ini. Namun, alokasi lokasi memori ke objek data merupakan masalah perangkat
lunak.
Tujuannya adalah untuk menemukan objek data sehingga hanya satu objek yang benar-benar dibagikan yang
terjadi per bingkai blok cache di memori dan tidak ada objek yang tidak dibagikan yang terletak di bingkai
blok cache yang sama dengan objek yang dibagikan. Jika ini dilakukan, bahkan dengan hanya satu bit yang
valid per blok cache, pembagian palsu tidak mungkin dilakukan. Perhatikan bahwa objek yang dibagikan,
akses hanya-baca dapat digabungkan dalam satu blok cache dan tidak berkontribusi pada masalah berbagi yang
salah karena blok cache tersebut dapat dipegang oleh banyak cache dan diakses sesuai kebutuhan tanpa
pembatalan yang menyebabkan cache yang tidak perlu. rindu.

Sejauh objek data bersama secara eksplisit diidentifikasi dalam kode sumber program, maka kompiler harus, dengan
pengetahuan tentang detail hierarki memori, dapat menghindari penempatan lebih dari satu objek tersebut dalam bingkai
blok cache di memori. Jika objek bersama tidak dideklarasikan, maka arahan pemrogram mungkin perlu ditambahkan ke
program. Bingkai blok cache yang tersisa tidak boleh berisi data yang akan menyebabkan kesalahan berbagi yang salah.
Solusi yang pasti adalah dengan memblokir dengan lokasi yang tidak direferensikan.
Mengisi bingkai blok cache yang berisi objek data bersama dengan lokasi memori yang tidak digunakan dapat
menyebabkan penggunaan ruang memori yang agak tidak efisien. Blok cache mungkin berisi objek bersama plus objek
yang hanya dapat dibaca sebagai trade-off antara efisiensi penggunaan memori dan menimbulkan beberapa kesalahan
berbagi yang salah. Pengoptimalan ini hampir pasti membutuhkan analisis pemrogram untuk menentukan apakah ini
bermanfaat. Secara umum, perhatian yang cermat terhadap distribusi data sehubungan dengan jalur cache dan mempartisi
perhitungan di seluruh prosesor diperlukan.
5.26 Masalah mengilustrasikan kompleksitas protokol koherensi cache. Dalam hal ini, ini dapat berarti bahwa prosesor P1
mengeluarkan blok cache dari cache-nya dan segera meminta blok tersebut dalam instruksi berikutnya. Mengingat
bahwa pesan tulis kembali lebih panjang dari pesan permintaan, dengan jaringan yang memungkinkan permintaan yang
tidak berurutan, permintaan baru dapat tiba sebelum tulis kembali tiba di direktori. Salah satu solusi untuk masalah ini
adalah membuat direktori menunggu penulisan kembali dan kemudian menanggapi permintaan tersebut. Sebagai
alternatif, direktori dapat mengirimkan sebuah negative acknowledgement (NACK). Perhatikan bahwa solusi ini perlu
dipikirkan dengan sangat hati-hati karena berpotensi menyebabkan kebuntuan berdasarkan rincian implementasi tertentu
dari sistem. Metode formal sering digunakan untuk memeriksa balapan dan kebuntuan.
5.27 Jika petunjuk pengganti digunakan, maka CPU yang mengganti sebuah blok akan mengirimkan petunjuk ke direktori home dari
blok yang diganti. Petunjuk seperti itu akan mengarahkan direktori home untuk menghapus CPU dari daftar berbagi untuk
blok tersebut. Itu akan menyimpan pesan tanggal tidak valid ketika blok akan ditulis oleh beberapa CPU lain. Perhatikan
bahwa sementara petunjuk pengganti mungkin mengurangi total latensi protokol yang terjadi saat menulis blok, itu tidak
mengurangi lalu lintas protokol (petunjuk menghabiskan bandwidth sebanyak yang tidak valid).
5.28 sebuah. Mempertimbangkan terlebih dahulu persyaratan penyimpanan untuk node yang merupakan cache di bawah subpohon
direktori:
Direktori di tingkat mana pun harus mengalokasikan entri untuk semua blok cache yang di-cache di bawah subpohon
direktori itu. Dalam kasus terburuk (semua CPU di bawah subtree tidak berbagi blok apa pun), direktori harus menyimpan
entri sebanyak jumlah blok dari semua cache yang tercakup dalam subtree.
Itu berarti direktori root mungkin harus mengalokasikan entri yang cukup untuk mereferensikan semua blok dari
semua cache. Setiap blok memori yang di-cache dalam direktori akan diwakili oleh entri <alamat blok, vektor k-bit>,
vektor k-bit akan memiliki bit yang menentukan semua subpohon yang memiliki salinan blok.
Sebagai contoh, untuk sebuah pohon biner sebuah entri <m, 11> berarti bahwa blok m di-cache di bawah kedua
cabang pohon tersebut. Lebih tepatnya, satu bit per subtree akan

Bab 5 Solusi ÿ 59
Akar (Tingkat 0)
Direktori
k-1
0
Tingkat 1 Tingkat 1
Direktori Direktori
Tingkat L-1
Direktori
CPU0 CPU1 CPUk-1
Gambar S.36 Hierarki direktori berbasis pohon (pohon k-ary dengan l level).
memadai jika hanya status valid/tidak valid yang perlu dicatat; namun untuk merekam
apakah suatu blok dimodifikasi atau tidak, diperlukan lebih banyak bit. Perhatikan
bahwa tidak diperlukan entri jika blok tidak di-cache di bawah subtree.
Jika blok cache memiliki m bit (tag + indeks) maka bit status dan s perlu disimpan per
blok, dan cache dapat menampung b blok, maka direktori pada level L-1 (level terendah
tepat di atas CPU) harus tahan k × b entri.
Setiap entri akan memiliki (m + k × s) bit. Jadi setiap direktori pada level L-1 akan
memiliki (mkb + k2 bs) bit. Pada tingkat hierarki berikutnya, direktori akan menjadi
k kali lebih besar. Jumlah direktori pada level i adalah ki Untuk .
mempertimbangkan blok memori dengan rumah di subtree yang di-cache di luar
subtree. Persyaratan penyimpanan per direktori harus dimodifikasi.
Garis besar perhitungan:
Perhatikan bahwa untuk beberapa direktori (misalnya yang ada di level l-1) jumlah simpul
rumah yang mungkin dapat di-cache di luar subpohon sama dengan (b × ( kl
– x)), di mana kl adalah jumlah total CPU , b adalah jumlah blok per cache dan x adalah
jumlah CPU di bawah pohon sub direktori. Perlu dicatat bahwa penyimpanan tambahan
berkurang untuk direktori di tingkat pohon yang lebih tinggi (misalnya direktori di tingkat 0
tidak memerlukan penyimpanan seperti itu karena semua blok memiliki rumah di subpohon
direktori tersebut). B. Simulasi.

5.29 Menguji dan menetapkan kode menggunakan load linked dan store conditional.
MOV R3, #1
LL R2, 0(R1)
SC R3, 0(R1)
Biasanya kode ini akan dimasukkan ke dalam lingkaran yang berputar sampai 1 dikembalikan di R3.
5.30 Asumsikan baris cache yang memiliki variabel sinkronisasi dan data yang dijaga oleh variabel
sinkronisasi tersebut dalam baris cache yang sama. Asumsikan sistem dua prosesor dengan
satu prosesor melakukan banyak penulisan pada data dan prosesor lainnya memutar variabel
sinkronisasi. Dengan protokol yang tidak valid, pembagian yang salah akan berarti bahwa
setiap akses ke jalur cache berakhir dengan kegagalan yang mengakibatkan penalti kinerja
yang signifikan.
5.31 Monitor harus ditempatkan pada titik yang dilalui oleh semua akses memori.
Satu tempat yang cocok akan berada di pengontrol memori di beberapa titik di mana akses dari
4 inti bertemu (karena akses tidak di-cache). Monitor akan menggunakan semacam cache di
mana tag dari setiap entri yang valid adalah alamat yang diakses oleh beberapa instruksi terkait
beban. Di bidang data entri, nomor inti yang menghasilkan akses tertaut beban - yang alamatnya
disimpan di bidang tag - disimpan.
Beginilah cara monitor bereaksi terhadap akses memori yang berbeda.
ÿ Baca tidak berasal dari instruksi terkait beban:

ÿ Melewati progres monitor untuk membaca data dari memori ÿ
Membaca yang berasal dari instruksi terkait beban:
ÿ Memeriksa cache, jika ada entri yang alamatnya cocok dengan alamat baca
meskipun ada sebagian alamat yang cocok (misalnya, baca [0:7] dan baca [4:11]
cocok dengan alamat yang tumpang tindih [4:7 ]), entri cache yang cocok tidak
valid dan entri baru dibuat untuk pembacaan baru (mencatat nomor inti
miliknya). Jika tidak ada entri yang cocok di cache, entri baru akan dibuat (jika
ada ruang di cache). Dalam kedua kasus, pembacaan berlanjut ke memori dan
mengembalikan data ke inti asal.
ÿ Tulis tidak berasal dari instruksi bersyarat toko: ÿ Periksa
cache, jika ada entri yang alamatnya cocok dengan alamat tulis meskipun ada
sebagian alamat yang cocok (misalnya, baca [0:7] dan tulis [4 :11] alamat
yang cocok tumpang tindih [4:7]), entri cache yang cocok tidak
valid. Penulisan berlanjut ke memori dan menulis data ke alamat yang
dimaksud.
ÿ Tulis yang berasal dari instruksi store-conditional:

ÿ Memeriksa cache, jika ada entri yang alamatnya cocok dengan alamat tulis
meskipun ada sebagian alamat yang cocok (misalnya, baca [0:7] dan tulis [4:11]
cocok dengan alamat yang tumpang tindih [4:7 ]), nomor inti dalam entri cache
dibandingkan dengan inti asal penulisan.

Bab 5 Solusi ÿ 61
Jika nomor inti sama, maka entri cache yang cocok tidak valid, proses penulisan ke
memori dan mengembalikan sinyal sukses ke inti asal. Dalam hal ini, kami
mengharapkan pencocokan alamat menjadi sempurna – bukan parsial- seperti yang kami
harapkan bahwa inti yang sama tidak akan mengeluarkan pasangan instruksi bersyarat load-
linked/store yang memiliki rentang alamat yang tumpang tindih.
Jika nomor inti berbeda, maka entri cache yang cocok tidak valid, penulisan dibatalkan dan
mengembalikan sinyal kegagalan ke inti asal. Kasus ini menandakan bahwa variabel
sinkronisasi telah rusak oleh inti lain atau oleh beberapa operasi penyimpanan biasa.
5.32 sebuah. Karena flag ditulis hanya setelah A ditulis, kita berharap C menjadi 2000, nilai A.
B. Kasus 1: Jika penulisan ke bendera mencapai P2 lebih cepat daripada penulisan ke A.
Kasus 2: Jika pembacaan ke A lebih cepat daripada pembacaan ke penanda.
C. Pastikan bahwa penulisan oleh P1 dilakukan dalam urutan program dan bahwa operasi memori
dijalankan secara atomis sehubungan dengan operasi memori lainnya.
Untuk mendapatkan hasil konsistensi sekuensial yang intuitif menggunakan instruksi penghalang,
penghalang perlu disisipkan di P1 antara tanda tulis ke A dan tanda tulis ke.
5.33 Inklusi menyatakan bahwa setiap level cache yang lebih tinggi berisi semua nilai yang ada di level cache yang lebih rendah,
misalnya, jika sebuah blok ada di L1 maka itu juga ada di L2. Soal menyatakan bahwa L2
memiliki asosiatif yang sama atau lebih tinggi dari L1, keduanya menggunakan LRU, dan keduanya memiliki ukuran
blok yang sama.
Ketika miss dilayani dari memori, blok ditempatkan ke semua cache, yaitu ditempatkan di L1 dan L2.
Juga, hit di L1 dicatat di L2 dalam hal memperbarui informasi LRU. Properti kunci lain dari LRU
adalah sebagai berikut. Misalkan A dan B keduanya adalah himpunan yang elemennya diurutkan
berdasarkan penggunaan terakhirnya. Jika A adalah himpunan bagian
dari B sedemikian rupa sehingga mereka berbagi elemen yang terakhir digunakan, maka elemen
LRU dari B harus merupakan elemen LRU dari A atau bukan elemen dari A.
Ini hanya menyatakan bahwa urutan LRU adalah sama terlepas dari apakah ada 10 entri atau 100.
Mari kita asumsikan bahwa kita memiliki blok, D, yang ada di L1, tetapi tidak di L2. Karena D
awalnya harus tinggal di L2, pasti sudah digusur. Pada saat penggusuran, D pasti merupakan blok
yang paling jarang digunakan. Sejak penggusuran L2 terjadi, prosesor pasti telah meminta blok yang
bukan penduduk di L1 dan jelas bukan di L2. Blok baru dari memori ditempatkan di L2 (menyebabkan
penggusuran) dan ditempatkan di L1 menyebabkan penggusuran lagi. L1 akan memilih blok yang
paling jarang digunakan untuk diusir.
Karena kita tahu bahwa D ada di L1, itu pasti entri LRU karena itu adalah entri LRU di L2 dengan
argumen yang dibuat di paragraf sebelumnya. Ini berarti L1 harus memilih D untuk
diusir. Hal ini menyebabkan D tidak berada di L1 yang menghasilkan kontradiksi dari apa yang
kita asumsikan. Jika sebuah elemen berada di L1, ia harus berada di L2 (inklusi)
mengingat asumsi masalahnya tentang cache.

5.34 Model analitis dapat digunakan untuk mendapatkan wawasan tingkat tinggi tentang perilaku sistem dalam waktu
yang sangat singkat. Biasanya, tantangan terbesar adalah dalam menentukan nilai parameter. Selain itu,
sementara hasil dari model analitik dapat memberikan perkiraan yang baik dari tren relatif yang diharapkan,
mungkin terdapat kesalahan yang signifikan dalam prediksi absolut.
Simulasi berbasis jejak biasanya memiliki akurasi yang lebih baik daripada model analitik, tetapi membutuhkan
waktu lebih lama untuk menghasilkan hasil. Keuntungannya adalah bahwa pendekatan ini bisa cukup akurat
ketika berfokus pada komponen sistem tertentu (mis., sistem cache, sistem memori, dll.). Namun, metode ini
tidak memodelkan dampak dari prosesor yang agresif (jalur yang salah prediksi) dan mungkin tidak
memodelkan urutan akses yang sebenarnya dengan penataan ulang. Jejak juga bisa berukuran sangat besar,
seringkali memakan gigabyte penyimpanan, dan penting untuk menentukan panjang jejak yang cukup untuk
hasil yang dapat dipercaya. Juga sulit untuk menghasilkan pelacakan representatif dari satu kelas mesin yang
akan valid untuk semua
kelas mesin yang disimulasikan. Juga lebih sulit untuk memodelkan sinkronisasi pada sistem ini tanpa
mengabstraksi sinkronisasi dalam jejak ke primitif tingkat tinggi mereka.
Simulasi yang digerakkan oleh eksekusi memodelkan semua komponen sistem secara detail dan akibatnya
merupakan yang paling akurat dari ketiga pendekatan tersebut. Namun, kecepatan simulasinya jauh lebih
lambat daripada model lainnya. Dalam beberapa kasus, detail ekstra mungkin tidak diperlukan untuk
parameter desain tertentu yang menarik.
5.35 Salah satu cara untuk merancang tolok ukur multiprosesor/cluster yang kinerjanya semakin buruk saat prosesor
ditambahkan: Buat tolok
ukur sedemikian rupa sehingga semua prosesor memperbarui variabel yang sama atau sekelompok kecil
variabel secara terus-menerus setelah perhitungan yang sangat sedikit.
Untuk multiprosesor, tingkat kesalahan dan invalidasi berkelanjutan di antara akses dapat
berkontribusi lebih banyak pada waktu eksekusi daripada perhitungan sebenarnya, dan
menambahkan lebih banyak CPU dapat memperlambat waktu eksekusi keseluruhan.
Untuk kluster yang diatur sebagai cincin komunikasi, biaya yang diperlukan untuk memperbarui
variabel umum dapat menyebabkan perilaku percepatan linier terbalik karena lebih banyak prosesor
ditambahkan.


CS422 Computer Architecture A Quantitative Approach Solution For 5th Edition

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

CS422 Computer Architecture A Quantitative Approach Solution For 5th Edition

Diunggah oleh

Hak Cipta:

Format Tersedia

Machine Translated by Google

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

Solusi untuk Studi Kasus dan Latihan

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

2 ÿ Solusi untuk Studi Kasus dan Latihan

proses mereka disetel, dan tingkat kecacatan menurun.

Untung = 416 × 0,65 × $20 = $5408

Untung = 240 × 0,50 × $25 = $3000

C. Chip Woods d. Woods

chips: 50.000/416 = 120,2 wafer yang dibutuhkan Markon chips: 25.000/240

120 Woods wafer, 30 Markon wafer.

Tidak ada cacat = 0,282 = 0,08 Satu

cacat = 0,28 × 0,72 × 2 = 0,40 Tidak lebih dari satu

cacat = 0,08 + 0,40 = 0,48

$20 × 0,28 = Ukuran wafer/dpw lama

Ukuran wafer $20 0,28 ×

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

Studi Kasus 2: Konsumsi Daya di Sistem Komputer

B. 0,6 × 4 W + 0,4 × 7,9 = 5,56

C. Selesaikan empat persamaan berikut:

C. 200 W × 11 = 2200 W 2200/

1.7 sebuah. (1 – 8) + 0,8/2 = 0,2 + 0,4 = 0,6

1.8 sebuah. (1,35)10 = kira-kira 20 b. 3200 ×

(1,4)12 = sekitar 181.420 c. 3200 × (1,01)12 = kira-

kira 3605 d. Kepadatan daya, yaitu daya yang

4 ÿ Solusi untuk Studi Kasus dan Latihan

C. Daya baru/Daya lama = ½ Kapasitansi × (Tegangan × 0,8)2 × (Frekuensi × 0,6)/½

1.12 sebuah. 35/10000 × 3333 = 11,67 hari

B. Opteron: 0,6 × 0,92 + 0,2 × 1,03 + 0,2 × 0,65 = 0,888

1.14 sebuah. Lihat Gambar

S.1. B. 2 = 1/((1 – x) + x/10)

0,056/0,5 = 0,11 atau 11%

D. Percepatan maksimum = 1/(1/10) = 10 5 =

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

Gambar S.1 Plot persamaan: y = 100/((100 – x) + x/10).

e. Percepatan saat ini: 1/(0,3 + 0,7/10) = 1/0,37 = 2,7 Sasaran

1.16 sebuah. 1/(0,8 + 0,20/2) = 1,11

B. 1/(0,7 + 0,20/2 + 0,10 × 3/2) = 1,05

C. operasi fp: 0,1/0,95 = 10,5%, tembolok: 0,15/0,95 = 15,8% 1.17

B. 1/(0,01 + 0,99/2) = 1,98

D. 1/(0,8 + 0,2 × 0,01 + 0,2 × 0,99/2) = 1/(0,8 + 0,002 + 0,099) = 1,11

1.18 sebuah. 1/(.2 + .8/N)

C. 1/(.2 + 3 × 0,005 + 0,8/8) = 3,17

D. 1/(.2 + logN × 0,005 + 0,8/N) e. d/

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

6 ÿ Solusi untuk Studi Kasus dan Latihan

C. untuk (i = 0; i < 256; i=i+B) {

2.3 Buka latihan langsung, tidak ada solusi tetap.

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

Studi Kasus 2: Menyatukan Semuanya: Sangat Paralel

asosiatif set 8 arah. D. Memori utama adalah 512MB.

e. Berjalan melalui halaman dengan

B. Petunjuk: Bandingkan kinerja referensi independen sebagai fungsi dari

2.7 Buka latihan langsung, tidak ada solusi pasti.

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

8 ÿ Solusi untuk Studi Kasus dan Latihan

Asosiatif himpunan 4 arah = 1,37ns @ ,83ns waktu siklus = 2 siklus Asosiatif

D. Akses serial adalah 2.4ns/1.59ns = 1.509 atau 51% lebih lambat.

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

4 bit. B. Panjang semburan 4 membaca 32B.

Bandwidth DDR-533 DIMM adalah 533 × 8 = 4264 MB/s.

Hak Cipta © 2012 Elsevier, Inc. Semua hak dilindungi undang-undang.

10 ÿ Solusi untuk Studi Kasus dan Latihan