single vs multi cycle processor 2

• In this implementation, every instruction requires one
cycle to complete -> cycle time = time taken for the
slowest instruction
• If the execution was broken into multiple (faster)
cycles, the shorter instructions can finish sooner

• Dalam pelaksanaannya, setiap instruksi memerlukan satu
siklus untuk melengkapi -> siklus waktu = waktu yang dibutuhkan untuk
paling lambat instruksi
• Jika eksekusi itu pecah menjadi beberapa (lebih cepat)
siklus, instruksi yang lebih pendek dapat menyelesaikan lebih cepat

private and shared L2 cache

• Advantages of a shared L2 cache:
- efficient dynamic allocation of space to each core
- data shared by multiple cores is not replicated
- every block has a fixed "home" - hence, easy to find
the latest copy
• Advantages of a private L2 cache:
- quick access to private L2 - good for small working sets
- private bus to private L2 -> less contention

• Keuntungan dari shared L2 cache:
- dinamis efisien alokasi ruang untuk masing-masing inti
- data bersama oleh beberapa core tidak direplikasi
- setiap blok memiliki tetap "rumah" - maka, mudah untuk menemukan
salinan terbaru

• Keuntungan dari cache L2 pribadi:
- akses cepat ke L2 pribadi - baik untuk bekerja kecil set
- bus swasta swasta L2 -> kurang pendapat

fine-grained and simultaneous multithreading

• Superscalar processor has high under-utilization – not enough work every
cycle, especially when there is a cache miss
• Fine-grained multithreading can only issue instructions from a single thread
in a cycle – can not find max work every cycle, but cache misses can be tolerated
• Simultaneous multithreading can issue instructions from any thread every
cycle – has the highest probability of finding work for every issue slot

--------------------------------------------------------------

• Superscalar prosesor memiliki tinggi di bawah pemanfaatan - tidak cukup bekerja setiap
siklus, terutama jika ada cache miss
• Fine-grained multithreading hanya dapat dikeluarkan instruksi dari satu thread
dalam satu siklus - tidak dapat menemukan pekerjaan maks setiap siklus, namun meleset cache dapat ditoleransi
• Simultaneous multithreading dapat mengeluarkan instruksi dari setiap thread setiap
siklus - memiliki probabilitas tertinggi mencari pekerjaan untuk setiap masalah slot

multithreading

• Until now, we have executed multiple threads of an
application on different processors > can multiple
threads execute concurrently on the same processor?

• Why is this desireable?
> inexpensive – one CPU, no external interconnects
> no remote or coherence misses (more capacity misses)

• Why does this make sense?
> most processors can’t find enough work – peak IPC
is 6, average IPC is 1.5!
> threads can share resources - we can increase
threads without a corresponding linear increase in area

---------------------------------------------------------------

. Hingga kini, kami telah melaksanakan beberapa benang dari
aplikasi pada prosesor yang berbeda> bisa beberapa
benang mengeksekusi bersamaan pada prosesor yang sama?

. Mengapa diinginkan ini?
> Murah satu CPU, tidak ada interkoneksi eksternal
> Tidak terpencil atau koherensi meleset (meleset kapasitas yang lebih besar)

. Mengapa hal ini masuk akal?
> Kebanyakan prosesor tidak menemukan cukup bekerja - puncak IPC
adalah 6, IPC rata-rata adalah 1,5!
> Benang dapat berbagi sumber daya kita dapat meningkatkan
benang tanpa peningkatan linier yang sesuai di daerah

lock

• Applications have phases (consisting of many instructions)
that must be executed atomically, without other parallel
processes modifying the data
• A lock surrounding the data/code ensures that only one
program can be in a critical section at a time
• The hardware must provide some basic primitives that
allows us to construct locks with different properties

-----------------------------------------------------------------

• Aplikasi mempunyai fase (terdiri dari banyak instruksi)
yang harus dijalankan atom, tanpa paralel lain
proses memodifikasi data
• Sebuah kunci yang mengelilingi data / kode memastikan bahwa hanya satu
program dapat di bagian kritis pada suatu waktu
• Perangkat keras harus memberikan primitif dasar yang
memungkinkan kita untuk membangun kunci dengan sifat yang berbeda

M E S I

Modified
The cache line is present only in the current cache, and is dirty; it has been modified from the value in main memory. The cache is required to write the data back to main memory at some time in the future, before permitting any other read of the (no longer valid) main memory state. The write-back changes the line to the Exclusive state.

Exclusive
The cache line is present only in the current cache, but is clean; it matches main memory. It may be changed to the Shared state at any time, in response to a read request. Alternatively, it may be changed to the Modified state when writing to it.

Shared
Indicates that this cache line may be stored in other caches of the machine & is "clean" ; it matches the main memory. The line may be discarded (changed to the Invalid state) at any time.

Invalid
Indicates that this cache line is invalid.


-----------------------------------------------------------

Dimodifikasi
Garis cache hadir hanya dalam cache saat ini, dan kotor; ini telah dimodifikasi dari nilai di memori utama. Cache dibutuhkan untuk menulis data kembali ke memori utama pada suatu waktu di masa depan, sebelum mengizinkan membaca lain (yang tidak berlaku lagi) memori utama negara. Write-back yang mengubah baris ke negara Eksklusif.

Eksklusif
Garis cache hadir hanya dalam cache saat ini, tetapi bersih; kesesuaiannya memori utama. Mungkin berubah menjadi negara Shared setiap saat, sebagai tanggapan atas permintaan membaca. Atau, mungkin akan diubah ke negara Modifikasi saat menulis untuk itu.

Shared
Menunjukkan bahwa baris cache ini dapat disimpan dalam cache lain dari mesin & adalah "bersih"; itu sesuai dengan memori utama. Garis dapat dibuang (berubah menjadi negara tidak valid) pada setiap saat.

Valid
Menunjukkan bahwa baris cache ini tidak valid.

contoh snooping

• P1 reads X: not found in cache-1, request sent on bus, memory responds,
X is placed in cache-1 in shared state

• P2 reads X: not found in cache-2, request sent on bus, everyone snoops
this request, cache-1does nothing because this is just a read request,
memory responds, X is placed in cache-2 in shared state

• P1 writes X: cache-1 has data in shared
state (shared only provides read perms),
request sent on bus, cache-2 snoops and
then invalidates its copy of X, cache-1
moves its state to modified

• P2 reads X: cache-2 has data in invalid
state, request sent on bus, cache-1 snoops
and realizes it has the only valid copy, so it
downgrades itself to shared state and
responds with data, X is placed in cache-2
in shared state

----------------------------------------------------------------------

• P1 dibaca X: tidak ditemukan dalam cache-1, permintaan yang dikirimkan pada bus, memori menjawab,
X ditempatkan dalam cache-1 di negara berbagi

• P2 dibaca X: tidak ditemukan dalam cache-2, permintaan yang dikirimkan pada bus, semua orang snoops
permintaan ini, cache-1does apa-apa karena ini hanya sebuah permintaan membaca,
menanggapi memori, X ditempatkan dalam cache-2 di negara berbagi

• P1 menulis X: cache-1 memiliki data dalam berbagi
negara (shared hanya menyediakan membaca perms),
permintaan yang dikirimkan pada bus, cache-2 snoops dan
kemudian membatalkan yang salinan X, cache-1
bergerak dengan negara untuk diubah

• P2 dibaca X: cache-2 memiliki data yang tidak valid
negara, permintaan yang dikirimkan pada bus, cache-1 snoops
dan menyadari itu hanya memiliki salinan sah, sehingga
mengerdilkan dirinya sendiri untuk berbagi negara dan
merespons dengan data, X ditempatkan dalam cache-2
di negara berbagi

cache coherence protocol

• Directory-based: A single location (directory) keeps track
of the sharing status of a block of memory
• Snooping: Every cache block is accompanied by the sharing
status of that block – all cache controllers monitor the
shared bus so they can update the sharing status of the
block, if necessary

- Write-invalidate: a processor gains exclusive access of
a block before writing by invalidating all other copies
- Write-update: when a processor writes, it updates other
shared copies of that block

• Directory-based: A satu lokasi (direktori) melacak
dari status berbagi blok memori
• mengintai: Setiap cache blok tersebut dibarengi dengan berbagi
status yang menghambat - semua cache controller memantau
bus bersama sehingga mereka dapat memperbarui status berbagi
blok, jika perlu

- Tulis-membatalkan: sebuah prosesor memperoleh akses eksklusif
blok sebelum menulis dengan mengabaikan semua salinan lain
- Tulis-update: ketika sebuah prosesor menulis, memperbarui lain
berbagi salinan dari blok

Distributed Memory Multiprocessors

SMP

taxonomy multiprocessor

• SISD: single instruction and single data stream: uniprocessor
• MISD: no commercial multiprocessor: imagine data going
through a pipeline of execution engines
• SIMD: vector architectures: lower flexibility
• MIMD: most multiprocessors today: easy to construct with
off-the-shelf computers, most flexibility

• SISD: single instruksi dan aliran data tunggal: Uniprocessor
• MISD: tidak komersial multiprosesor: bayangkan data yang akan
melalui pipa mesin eksekusi
• SIMD: vektor arsitektur: fleksibilitas yang lebih rendah
• MIMD: paling Multiprocessors today: mudah untuk membangun dengan
off-the-rak komputer, paling fleksibilitas

RAID

---- RAID 0 and RAID 1 ----

• RAID 0 has no additional redundancy (misnomer) – it
uses an array of disks and stripes (interleaves) data
across the arrays to improve parallelism and throughput
• RAID 1 mirrors or shadows every disk – every write
happens to two disks
• Reads to the mirror may happen only when the primary
disk fails – or, you may try to read both together and the
quicker response is accepted

• RAID 0 tidak memiliki redundansi tambahan (ironi) - itu
menggunakan sebuah array disk dan garis-garis (interleaves) data
seluruh array untuk meningkatkan paralelisme dan throughput
• RAID 1 mirror atau bayangan setiap disk - setiap menulis
terjadi pada dua disk
• Dibaca ke cermin mungkin terjadi hanya bila utama
disk gagal - atau, Anda dapat mencoba membaca baik bersama-sama dan
respons lebih cepat diterima

----RAID 3----

• Data is bit-interleaved across several disks and a separate
disk maintains parity information for a set of bits
• For example: with 8 disks, bit 0 is in disk-0, bit 1 is in disk-1,
…, bit 7 is in disk-7; disk-8 maintains parity for all 8 bits
• For any read, 8 disks must be accessed (as we usually
read more than a byte at a time) and for any write, 9 disks
must be accessed as parity has to be re-calculated
• High throughput for a single request, low cost for
redundancy (overhead: 12.5%), low task-level parallelism

• Data bit-interleaved di beberapa disk dan terpisah
disk menyimpan informasi paritas untuk satu set bit
• Sebagai contoh: dengan 8 disk, bit 0 adalah dalam disk-0, bit 1 adalah dalam disk-1,
..., Bit 7 adalah dalam disk-7; disk-8 mempertahankan paritas untuk semua 8 bit
• Untuk setiap membaca, 8 disk harus diakses (seperti yang kita biasanya
membaca lebih dari satu byte pada suatu waktu) dan untuk menulis, 9 disk
harus diakses sebagai paritas harus dihitung ulang
• High throughput untuk satu permintaan, biaya rendah
redundansi (overhead: 12,5%), tingkat rendah paralelisme tugas

---RAID 4 adn RAID 5----

• Data is block interleaved – this allows us to get all our
data from a single disk on a read – in case of a disk error,
read all 9 disks
• Block interleaving reduces thruput for a single request (as
only a single disk drive is servicing the request), but
improves task-level parallelism as other disk drives are
free to service other requests
• On a write, we access the disk that stores the data and the
parity disk – parity information can be updated simply by
checking if the new data differs from the old data

• Data blok interleaved - ini memungkinkan kita untuk mendapatkan semua kita
data dari satu disk read - dalam kasus kesalahan disk,
membaca semua 9 disk
• Blok interleaving mengurangi thruput untuk satu permintaan (sebagai
hanya satu disk drive melayani permintaan), tetapi
meningkatkan tingkat paralelisme tugas sebagai disk drive yang lain
bebas untuk layanan permintaan lain
• Pada menulis, kita akses disk yang menyimpan data dan
paritas disk - paritas informasi dapat diperbarui hanya dengan
memeriksa apakah data baru berbeda dari data lama

----RAID 5----

• If we have a single disk for parity, multiple writes can not
happen in parallel (as all writes must update parity info)
• RAID 5 distributes the parity block to allow simultaneous
writes

• Jika kita memiliki satu disk untuk paritas, beberapa tidak bisa menulis
terjadi secara paralel (seperti semua menulis harus memperbarui paritas info)
• RAID 5 mendistribusikan paritas blok untuk memungkinkan secara simultan
menulis

----RAID SUMARY----

• RAID 1-5 can tolerate a single fault – mirroring (RAID 1)
has a 100% overhead, while parity (RAID 3, 4, 5) has
modest overhead
• Can tolerate multiple faults by having multiple check
functions – each additional check can cost an additional
disk (RAID 6)
• RAID 6 and RAID 2 (memory-style ECC) are not
commercially employed

• RAID 1-5 dapat mentolerir satu kesalahan - mirroring (RAID 1)
memiliki 100% di atas kepala, sedangkan paritas (RAID 3, 4, 5) memiliki
sederhana overhead
• Dapatkah mentolerir beberapa kesalahan dengan memiliki beberapa cek
fungsi - setiap tambahan biaya dapat memeriksa tambahan
disk (RAID 6)
• RAID 6 dan RAID 2 (gaya memori ECC) tidak
komersial dipekerjakan

polling vs interupt-driven

• When the I/O device is ready to respond, it can send an
interrupt to the CPU; the CPU stops what it was doing;
the OS examines the interrupt and then reads the data
produced by the I/O device (and usually stores into memory)
• In the polling approach, the CPU (OS) periodically checks
the status of the I/O device and if the device is ready with
data, the OS reads it

• Bila I / O device yang siap untuk merespon, hal itu dapat mengirim
interupsi ke CPU CPU berhenti apa yang dilakukannya;
OS memeriksa menyela dan kemudian membaca data
diproduksi oleh I / O device (dan biasanya toko ke memori)
• Pada pendekatan pemungutan suara, CPU (OS) secara berkala memeriksa
status I / O device dan jika perangkat sudah siap dengan
data, OS membacanya

DMA

• Consider a disk read example: a block in disk is being
read into memory
• For each word, the CPU does a
lw [destination register] [I/O device address] and a
sw [data in above register] [memory-address]
• This would take up too much of the CPU’s time – hence,
the task is off-loaded to the DMA controller – the CPU
informs the DMA of the range of addresses to be copied
and the DMA lets the CPU know when it is done

• Pertimbangkan membaca disk contoh: sebuah blok di disk yang
baca ke memori
• Untuk setiap kata, CPU melakukan
lw [tujuan daftar] [I / O device alamat] dan
sw [data di atas daftar] [alamat memori]
• Hal ini akan mengambil terlalu banyak dari waktu CPU - karenanya,
tugas off-load ke DMA controller - CPU
menginformasikan kepada DMA dari kisaran alamat yang akan disalin
dan DMA memungkinkan CPU tahu kapan itu dilakukan

bus design

• The bus is a shared resource – any device can send
data on the bus (after first arbitrating for it) and all other
devices can read this data off the bus
• The address/control signals on the bus specify the
intended receiver of the message
• The length of the bus determines its speed (hence, a
hierarchy makes sense)
• Buses can be synchronous (a clock determines when each
operation must happen) or asynchronous (a handshaking
protocol is used to co-ordinate operations)

• Bus adalah sumber daya bersama - setiap perangkat dapat mengirim
data pada bus (setelah pertama menengahi untuk itu) dan semua
perangkat dapat membaca data ini turun dari bus
• Alamat / kontrol sinyal di bus menentukan
dimaksudkan penerima pesan
• Panjang bus menentukan kecepatan (dengan demikian, seorang
hirarki masuk akal)
• Bus dapat sinkron (jam menentukan ketika masing-masing
operasi harus terjadi) atau asinkron (a handshaking
protokol yang digunakan untuk mengkoordinasi operasi)

TLB

• Since the number of pages is very high, the page table
capacity is too large to fit on chip
• A translation lookaside buffer (TLB) caches the virtual
to physical page number translation for recent accesses
• A TLB miss requires us to access the page table, which
may not even be found in the cache – two expensive
memory look-ups to access one word of data!
• A large page size can increase the coverage of the TLB
and reduce the capacity of the page table, but also
increases memory wastage

• Karena jumlah halaman yang sangat tinggi, tabel halaman
kapasitas terlalu besar untuk muat di chip
• Sebuah terjemahan lookaside buffer (TLB) cache virtual
halaman fisik terjemahan untuk mengakses terbaru
• Sebuah rindu BIS mengharuskan kita untuk mengakses halaman tabel, yang
bahkan mungkin tidak ditemukan dalam cache - dua mahal
melihat-up memori untuk mengakses data satu kata!
• ukuran halaman besar dapat meningkatkan jangkauan TLB
dan mengurangi kapasitas tabel halaman, tetapi juga
memori meningkatkan wastage

Memory Hierarchy Properties

• A virtual memory page can be placed anywhere in physical
memory (fully-associative)
• Replacement is usually LRU (since the miss penalty is
huge, we can invest some effort to minimize misses)
• A page table (indexed by virtual page number) is used for
translating virtual to physical page number
• The page table is itself in memory

• Sebuah halaman memori virtual dapat ditempatkan di manapun di fisik
memori (sepenuhnya-asosiatif)
• Penggantian biasanya LRU (karena hukuman miss
besar, kita bisa berinvestasi beberapa upaya untuk meminimalkan misses)
• Sebuah halaman tabel (diindeks oleh nomor halaman virtual) digunakan untuk
virtual menerjemahkan halaman fisik
• Halaman meja itu sendiri dalam memori

virtual memory

• Processes deal with virtual memory – they have the
illusion that a very large address space is available to
them
• There is only a limited amount of physical memory that is
shared by all processes – a process places part of its
virtual memory in this physical memory and the rest is
stored on disk (called swap space)
• Thanks to locality, disk access is likely to be uncommon
• The hardware ensures that one process cannot access
the memory of a different process

• Proses berurusan dengan virtual memory - mereka mempunyai
ilusi bahwa alamat yang sangat besar ruang yang tersedia untuk
mereka
• Hanya ada jumlah terbatas memori fisik yang
bersama oleh semua proses - proses tempat bagian dari
memori virtual dalam memori fisik dan sisanya adalah
disimpan pada disk (yang disebut swap)
• Terima kasih kepada lokalitas, akses disk cenderung jarang
• Perangkat keras memastikan bahwa satu proses tidak dapat mengakses
memori dari proses yang berbeda

type of cache misses

• Compulsory misses: happens the first time a memory
word is accessed – the misses for an infinite cache

• Capacity misses: happens because the program touched
many other words before re-touching the same word – the
misses for a fully-associative cache

• Conflict misses: happens because two words map to the
same location in the cache – the misses generated while
moving from a fully-associative to a direct-mapped cache

• Wajib miss: terjadi pertama kali memori
kata diakses - yang merindukan untuk cache yang tak terbatas

• Kapasitas miss: terjadi karena program menyentuh
banyak kata lain sebelum menyentuh kembali kata yang sama - yang
rindu untuk cache asosiatif penuh

• Konflik miss: terjadi karena dua kata peta ke
lokasi yang sama dalam cache - yang merindukan dihasilkan sementara
bergerak dari sepenuhnya-asosiatif ke cache dipetakan langsung

cache misses

* Pada write miss, Anda dapat memilih untuk membawa blok ke dalam cache (write-mengalokasikan) atau tidak (write-no-mengalokasikan)

* Pada read miss, Anda selalu membawa balok dalam (spasial dan lokalitas temporal) tapi Blok mana yang akan diganti?
1. tidak punya pilihan untuk direct-mapped cache
2. secara acak memilih salah satu cara untuk menggantikan
3. menggantikan cara yang paling-baru ini digunakan (LRU)
FIFO pengganti (round-robin)

write

* Ketika Anda menulis ke sebuah blok, apakah Anda juga memperbarui
salinan L2?
write-through: setiap menulis ke L1 menulis untuk L2
write-back: menandai blok kotor, ketika balok
akan diganti dari L1, L2 menulis kepada

* Writeback coalesces beberapa menulis ke sebuah blok L1 menjadi satu
L2 menulis

* Writethrough menyederhanakan protokol koherensi dalam
sistem multiprosesor sebagai L2 selalu memiliki arus
salinan data

aspek cache

• Data dan instruksi yang tersimpan pada chip DRAM - DRAM
adalah teknologi yang memiliki kepadatan agak tinggi, namun relatif miskin
latency - akses data dalam memori dapat mengambil banyak
sekitar 300 siklus sekarang!

• Oleh karena itu, beberapa data yang disimpan pada prosesor dalam suatu struktur
disebut cache - cache SRAM menggunakan teknologi, yang
lebih cepat, tetapi memiliki sedikit lebih rendah kepadatan

control hazard 2

- simpel teknik untuk menangani bahaya kios:
a. untuk setiap cabang, memperkenalkan sebuah stall cycle (catatan: setiap
6 instruksi adalah cabang!)

b. mengasumsikan cabang tidak diambil dan mulai mengambil yang
instruksi berikutnya. Jika cabang diambil, perlu perangkat keras
untuk membatalkan efek dari jalan yang salah-instruksi.

c. mengambil instruksi berikutnya (cabang delay slot) dan
jalankan tetap. Jika instruksi ternyata
jalan yang benar, pekerjaan dilakukan berguna. Jika
ternyata instruksi berada di jalan yang salah,
Program mudah-mudahan negara tidak hilang

structural hazard 2

¢ Contoh: suatu kesatuan instruksi dan data cache
tahap 4 (MEM) dan tahap 1 (IF) tidak pernah bertepatan
¢ kemudian instruksi dan semua penerusnya yang tertunda
sampai suatu siklus ditemukan ketika sumber daya yang gratis ini
adalah pipa gelembung
¢ Struktural bahaya mudah untuk menghilangkan - meningkatkan
sejumlah sumber daya (misalnya, menerapkan terpisah
instruksi dan data cache)

hazard

• Structural bahaya: instruksi yang berbeda di berbagai tahap
(atau tahap yang sama) yang saling bertentangan sumber daya yang sama
• Data bahaya: instruksi tidak dapat dilanjutkan karena
membutuhkan nilai yang belum dihasilkan oleh
instruksi sebelumnya
• Pengendalian bahaya: mengambil tidak dapat melanjutkan karena tidak
tidak tahu hasil dari cabang sebelumnya - kasus khusus
dari data bahaya - kategori terpisah karena mereka
diperlakukan dengan cara yang berbeda

hierarki memory

HIERARKI MEMORI TRADISIONAL


Hierarki Memori atau Memory Hierarchy dalam arsitektur komputer adalah sebuah pedoman yang dilakukan oleh para perancang demi menyetarakan kapasitas, waktu akses, dan harga memori untuk tiap bitnya. Secara umum, hierarki memori terdapat dua macam yakni hierarki memori tradisional dan hierarki memori kontemporer.

HIERARKI MEMORI
http://upload.wikimedia.org/wikipedia/id/7/74/Hierarki_Memori_Kontemporer.png

data hazard

Bahaya data terjadi ketika data yang dimodifikasi. Mengabaikan data potensi bahaya dapat menyebabkan kondisi ras (kadang dikenal sebagai ras bahaya). Ada tiga situasi bahaya data dapat terjadi di:

1. Dibaca setelah Write (RAW) atau True ketergantungan: Sebuah operand yang diubah dan dibaca segera setelah. Karena instruksi pertama mungkin tidak selesai ditulis ke operand, instruksi kedua dapat menggunakan data yang tidak benar.
2. Menulis setelah Baca (War) atau Anti ketergantungan: Membaca dan menulis operand segera setelah operand untuk yang sama. Karena menulis mungkin telah selesai sebelum membaca, membaca instruksi mungkin salah mendapatkan nilai tertulis baru.
3. Menulis setelah Tulis (waw) atau Output ketergantungan: Dua instruksi yang menulis operand yang sama dilakukan. Yang pertama dikeluarkan dapat menyelesaikan kedua, dan karena itu meninggalkan operand dengan nilai data yang salah.

control hazard

Percabangan bahaya (juga dikenal sebagai mengendalikan bahaya) terjadi ketika prosesor diperintahkan untuk cabang - yaitu, jika kondisi tertentu benar, maka melompat dari satu bagian dari aliran instruksi lain - tidak perlu untuk instruksi berikutnya secara berurutan. Dalam kasus seperti ini, prosesor tidak bisa mengatakan lebih dulu apakah harus memproses instruksi berikutnya (jika dapat daripada harus pindah ke instruksi yang jauh).

Hal ini dapat mengakibatkan prosesor melakukan tindakan yang tidak diinginkan.

structural hazard

Sebuah bahaya struktural terjadi ketika sebuah bagian dari hardware prosesor dibutuhkan oleh dua atau lebih instruksi pada waktu yang sama. Sebuah bahaya struktural mungkin terjadi, misalnya, jika program itu untuk mengeksekusi instruksi cabang yang diikuti oleh instruksi perhitungan. Karena mereka dijalankan secara paralel, dan karena biasanya bercabang lambat (memerlukan perbandingan, program counter, yang berhubungan dengan komputasi, dan menulis untuk register), sangat mungkin (tergantung pada arsitektur) bahwa perhitungan instruksi dan instruksi cabang akan keduanya membutuhkan yang ALU (arithmetic logic unit) pada waktu yang sama.

jenis hazard

1. (RAW) atau True Dependency: Sebuah operand yang diubah dan dibaca segera setelah. Karena instruksi pertama mungkin tidak selesai ditulis ke operand, instruksi kedua dapat menggunakan data yang tidak benar.

2. (WAR) atau Anti Dependency: Membaca dan menulis operand segera setelah operand untuk yang sama. Karena menulis mungkin telah selesai sebelum membaca, membaca instruksi mungkin salah mendapatkan nilai tertulis baru.

3. (WAW) atau Output Dependency: Dua instruksi yang menulis operand yang sama dilakukan. Yang pertama dikeluarkan dapat menyelesaikan kedua, dan karena itu meninggalkan operand dengan nilai data yang salah.

Keuntungan sistem Pipeline

1. Waktu siklus prosesor berkurang, sehingga meningkatkan tingkat instruksi-isu dalam kebanyakan kasus.
2. Beberapa combinational sirkuit seperti penambah atau pengganda dapat dibuat lebih cepat dengan menambahkan lebih banyak sirkuit. Jika pipelining digunakan sebagai pengganti, hal itu dapat menghemat sirkuit vs combinational yang lebih kompleks sirkuit.

keuntungan multi cycle-processor v single no 9

besar keuntungan dari siklus multi-desain adalah bahwa kita dapat menggunakan lebih atau kurang siklus untuk mengeksekusi setiap instruksi, tergantung pada kompleksitas instruksi. misalnya, kita dapat mengambil lima siklus untuk mengeksekusi instruksi beban, tetapi kita bisa mengambil hanya tiga siklus untuk mengeksekusi instruksi cabang. Kerugian besar dari desain multi-siklus meningkat kompleksitas. sekarang kontrol mesin negara yang terbatas - sebelum itu hanya combinational logika.


lain perbedaan penting antara siklus satu-desain dan multi-siklus desain adalah siklus waktu. dalam satu siklus prosesor, siklus waktu itu ditentukan oleh instruksi yang paling lambat. dalam multi-desain siklus, siklus waktu ditentukan oleh unit fungsional paling lambat [memori, register, alu]. ini sangat mengurangi waktu siklus kita.

keuntungan d-latch

Keuntungan dari D flip-flop di atas D-type latch adalah bahwa ia "menangkap" sinyal pada saat jam pergi tinggi, dan perubahan berikutnya baris data Q tidak mempengaruhi sampai jam tepi terbit berikutnya. Pengecualian adalah bahwa beberapa sandal jepit memiliki "reset" sinyal input, yang akan mengatur ulang Q (nol), dan mungkin baik asinkron atau sinkron dengan jam.

operasi 1 bit ALU

Operasi adalah:

* Menambahkan sedikit engan x dan y, dan membawa dalam, ci-1 (yang akan digunakan untuk menambahkan),
* Bitwise ANDing xi dan yi
* Bitwise ORing xi dan yi
* Memilih xi

Hukum De Morgan no 1

neg(p vee q) = (neg p)wedge(neg q).



Karena nilai dalam kolom 4 dan terakhir adalah sama bagi semua baris (yang mencakup semua kemungkinan nilai kebenaran penugasan ke variabel), kita dapat menyimpulkan dua ekspresi logis setara.

neg(p wedge q) = (neg p)vee(neg q)


Hukum dapat dibuktikan secara langsung dengan menggunakan tabel kebenaran; "1" mewakili benar, "0" mewakili false.

PEMBUKTIAN HUKUM DE MORGAN (a.b)' = a' +b'

(i) (ab)' = a' + b' (Hk. De Morgan)
(ii) aa' = 0 (Hk. Komplemen) --> (ab)(ab)' = 0 (komplemen)
Dari persamaan (i) dan (ii) didapat (ab)(a'+b") = 0

Bukti : (ab)(a'+b') = aba' + abb' (Distributif)
= 0.b + a.0 (Komplemen)
= 0 + 0 (Dominansi)
= 0

Jadi terbukti (a+b)' = a'b'

Untuk Hk. De Morgan yang lainnya, (a+b)' = a'b' gunakan dual dari jawaban diatas.
(Ubah + jadi - dan sebaliknya, 1 jadi 0 dan sebaliknya, biarkan tanda komplemen ['])