KAL
Menu

Register

Register sebagai penyimpanan multi-bit yang menahan nilainya sampai tepi clock berikutnya.

Daftar isi

Register adalah penyimpan multi-bit yang menahan nilainya sampai tepi clock berikutnya. Komponen ini muncul di mana saja di dalam prosesor, mulai dari penyimpan hasil sementara di samping ALU (Arithmetic Logic Unit) hingga program counter dan kata-kata di dalam memori. Topik ini membahas cara register disusun dari flip-flop, peran sinyal load dan enable, bentuk register file yang dipakai CPU, lalu menutupnya dengan simulasi kelas Register8 yang dapat dijalankan ulang.

Dari satu bit ke delapan bit#

Satu D flip-flop menyimpan satu bit, sedangkan nilai yang dikerjakan prosesor berukuran 8, 16, 32, atau 64 bit. Register dibangun dengan meletakkan sejumlah flip-flop secara paralel, semuanya berbagi clock yang sama. Delapan flip-flop paralel menghasilkan register 8 bit, dan karena semua flip-flop menyalin pada tepi yang sama, seluruh 8 bit berpindah serentak. Masukan D dan keluaran Q setiap flip-flop digabungkan menjadi satu bus masukan dan satu bus keluaran, sehingga register diperlakukan sebagai satu unit penyimpanan.

Susunan paralel ini menjelaskan konvensi gambar yang dipakai pada diagram di sepanjang jalur, yaitu register sebagai satu kotak dengan bus masukan di kiri dan bus keluaran di kanan. Di dalam kotak, flip-flop ke-0 menyimpan bit dengan bobot terkecil dan flip-flop ke-7 menyimpan bobot terbesar pada register 8 bit. Pembagian itu menjadi penting ketika nilai melebihi kapasitas, misalnya hasil penjumlahan yang membawa bit ke posisi kesembilan. Register 8 bit tidak memiliki tempat bagi bit kesembilan itu, sehingga rancangan harus menyatakan apa yang terjadi pada bit yang meluap, dan simulasi di bagian akhir menunjukkan pilihan yang paling sederhana.

Sinyal load dan enable#

Register yang sekadar menyalin pada setiap tepi belum berguna, karena nilainya pasti berubah setiap kali clock berdenyut. Sinyal load menyelesaikan masalah itu dengan menjadi syarat penulisan. Bila load bernilai 1 pada tepi naik, nilai masukan ditulis ke register, sedangkan bila load bernilai 0, nilai lama bertahan tanpa terpengaruh. Secara perangkat keras, penahanan ini dicapai dengan mux di depan setiap masukan D, yaitu ketika load aktif mux meneruskan masukan baru, dan ketika load nonaktif mux meneruskan kembali keluaran register itu sendiri.

python Mux di depan masukan D sebagai penahan nilai 
# tidak-dijalankan
if load == 1:
    masukan_d = nilai_baru    # mux meneruskan masukan baru
else:
    masukan_d = q_register    # mux meneruskan kembali nilai yang sudah ada

Enable adalah sinyal seleksi yang tugasnya berbeda dari load. Bila enable nonaktif, register tidak dipilih dan tepi clock diabaikan sama sekali, bahkan ketika load sedang aktif. Dua sinyal ini membentuk hierarki keputusan yang jelas, yaitu enable memilih register mana yang merespons, sedangkan load memutuskan apakah tepi itu menulis atau menahan. Pola enable-load ini dipakai ulang pada tingkat yang lebih besar, misalnya sebagai seleksi baris di dalam register file dan seleksi chip di dalam memori.

Register file dua port baca, satu port tulis#

CPU hampir tidak pernah memakai satu register sendirian. Sejumlah register disusun menjadi register file, yaitu larik register yang diberi nomor dan dilengkapi dua port baca serta satu port tulis. Dua port baca diperlukan karena instruksi aritmetika biasanya membaca dua operand sekaligus, sedangkan satu port tulis cukup karena satu tepi clock hanya menghasilkan satu hasil. Pemilihan register yang dibaca dan ditulis dilakukan dengan nomor register, yaitu deretan bit alamat yang diteruskan ke decoder, rangkaian pemilih satu dari banyak keluaran, di dalam register file.

python Kontrak register file: dua port baca, satu port tulis 
# tidak-dijalankan
nilai_a = register_file.baca(rs1)   # port baca pertama
nilai_b = register_file.baca(rs2)   # port baca kedua, aktif serentak
register_file.tulis(rd, hasil)      # port tulis, hanya pada tepi naik

Banyak arsitektur menyediakan 32 register umum dan menuliskan nomor registernya langsung di dalam bit instruksi. Register file mampu membaca dua register dalam waktu yang sama karena setiap port memiliki decoder dan jalur baca sendiri, tanpa menunggu dua tepi. Penulisan tetap tunggal pada setiap tepi, sehingga dua tulisan untuk dua register berbeda harus berlangsung pada dua tepi yang berurutan. Register bernomor 0 sering diperlakukan khusus, yaitu tulisan kepadanya dibuang karena nilainya menetap 0.

Simulasi Register8#

Kelas Register8 menggabungkan seluruh unsur yang sudah dibahas, yaitu penulisan hanya pada tepi naik, syarat load, seleksi enable, dan pemotongan ke 8 bit. Setiap baris tabel mewakili satu tepi clock beserta masukan dan sinyalnya. Tiga kejadian dirancang khusus pada jadwalnya, yaitu tepi dengan load 0, tepi dengan enable 0, dan masukan yang melebihi 255.

python register.py 
# Simulasi register 8 bit yang menulis hanya pada tepi naik clock,
# dengan sinyal load sebagai syarat tulis dan enable sebagai seleksi.

class Register8:
    """Register 8 bit dengan sinyal load dan enable."""

    MASK = 0xFF  # register 8 bit menampung nilai 0 sampai 255

    def __init__(self):
        self.nilai = 0

    def tepi_naik(self, masukan, load, enable=1):
        """Proses satu tepi naik: tulis masukan bila dipilih dan dimuat."""
        if enable == 0:
            return  # register tidak dipilih, tepi diabaikan
        if load == 1:
            self.nilai = masukan & self.MASK

    def baca(self):
        """Baca nilai yang sedang ditahan register."""
        return self.nilai


reg = Register8()
# Setiap baris mewakili satu tepi: (masukan, load, enable)
jadwal_tepi = [
    (37, 1, 1),   # ditulis
    (99, 0, 1),   # load nonaktif, nilai lama bertahan
    (99, 1, 0),   # enable nonaktif, tepi diabaikan meski load aktif
    (255, 1, 1),  # nilai baru menimpa nilai lama
    (300, 1, 1),  # 300 melebihi 8 bit, hanya 8 bit rendah yang tersimpan
]

print("tepi | masukan | load | enable | nilai register")
print("-----+---------+------+--------+---------------")
for nomor, (masukan, load, enable) in enumerate(jadwal_tepi, 1):
    reg.tepi_naik(masukan, load, enable)
    print(f"{nomor:4d} | {masukan:7d} | {load:4d} | {enable:6d} | {reg.baca():13d}")
text Keluaran 
tepi | masukan | load | enable | nilai register
-----+---------+------+--------+---------------
   1 |      37 |    1 |      1 |            37
   2 |      99 |    0 |      1 |            37
   3 |      99 |    1 |      0 |            37
   4 |     255 |    1 |      1 |           255
   5 |     300 |    1 |      1 |            44

Tepi kedua membuktikan bahwa load 0 membuat masukan 99 diabaikan, sehingga register masih menyimpan 37. Tepi ketiga menunjukkan kekuatan enable, karena masukan 99 dan load 1 sama-sama sudah siap, tetapi register yang tidak dipilih tidak bereaksi apa pun. Pada tepi kelima, masukan 300 melebihi 8 bit, sehingga yang tersimpan hanyalah 44, yaitu sisa pembagian 300 oleh 256. Urutan peristiwa di sini persis sama dengan cara prosesor memperbarui register hasilnya pada setiap tepi, hanya tanpa sinyal enable karena register tersebut selalu dipilih. Perilaku pemotongan itu bukan error model, melainkan perilaku register sungguhan, dan program yang menyimpan nilai melebihi lebar register memang menghadapi keputusan rancangan tentang penanganannya.

Ringkasan#

  • Register menyusun beberapa flip-flop paralel yang berbagi clock, sehingga seluruh bit berpindah serentak pada tepi naik.
  • Sinyal load menentukan apakah tepi menulis masukan baru atau menahan nilai lama melalui mux pada masukan D.
  • Enable memilih register yang merespons tepi, dan pola ini menjadi dasar seleksi alamat pada register file.
  • Register file memakai dua port baca dan satu port tulis agar dua operand terbaca sekaligus dalam satu langkah.

Referensi#