Memahami Bahasa Assembly

lewat Arsitektur Komputer

Tan Arman
tanarman@yahoo.com

Versi 1.01, 21 Oktober 2019

Pengantar
1. Kita memulai dengan Sejarah Mikroprosesor dan Mikroprosesor Intel.
2. Mengapa belajar Bahasa Assembly dan apa saja yang akan dipelajari ?
3. Memahami alur penerjemahan Bahasa Tingkat Tinggi ke Bahasa Mesin, bahasa alami perangkat keras.
4. Memahami lapisan ISA sebuah antarmuka antara hardware dan software yang mendorong adanya
Arsitektur CISC vs RISC.
5. Sisi perangkat keras komputer: CPU, Memory (Register, Cache dan RAM), peralatan Input-Output.
Arsitektur CPU menjelaskan tentang proses pengolahan instruksi dan data, bagaimana Register menjadi
sarana penyimpanan dan pengolahan oleh CPU dalam melakukan tugas2 nya yakkni aritmetika, logic dan
kontrol.
Yang berkaitan dengan memori adalah memori yang berada dalam CPU (Register), dalam IC bersama CPU
(Cache) dan di luar CPU (RAM dan ROM). Topik utama memori adalah pengalamatan (addessing) yakni
bagaimana mengambil dan menyimpan instruksi dan data (per byte) dari dan ke memori.
Peralatan Input-Output memanfaatkan teknik Intterupt untuk mendapatkan perhatian dari CPU.
6. Sisi perangkat lunak mempelajari bagaimana memori diduduki oleh sistem operasi dan cara2
mengaksesnya dari aplikasi. Konsep tentang Interrupt diperjelas lagi lebih lengkap, begitu pula tentang
stack. Di sini Anda akan dipersiapkan dengan tools untuk mulai bekerja. Anda akan melihat bagaimana
Bahasa Tingkat Tinggi, Bahasa Assembly dan Bahasa Mesin bersambungan sehingga selanjutnya Anda akan
percaya diri bermain dengan Bahasa Assembly.
• Jantung komputer adalah mikroprosesor (µP) yang menangani kebutuhan komputer atas aritmetika, logic dan
kontrol. Mikroprosesor bermuara di tahun 1960-an1) ketika para perancang peneliti memanfaatkan rangkaian
terpadu atau integrated circuit (IC) dengan menggabungkan beragam komponen elektronik menjadi satu
komponen tunggal dalam sebuah emping silikon (silicon chip). Pabrikan membuatnya seperti piranti
menyerupai kelabang dan IC2 disambung2 menjadi sebuah sistem yang berfungsi. Pada April 1972, Intel®
memperkenalkan chip 8008, generasi pertama mikroprosesor 8-bit.
• Pada tahun 1974, 8008 berkembang menjadi 8080, mikroprosesor generasi kedua yang begitu populer
pemanfaatannya sebagai general-purpose. Pada tahun 1978 keluar generasi ketiga prosesor 8086 yang
kompatibel dengan 8080 dan desainnya jauh ke depan.
• Berikutnya Intel® mengembangkan 80882), suatu variasi dari 8086 yang memiliki desain lebih sederhana dan
kompatibel terutama bagian perangkat input/output. 8088 inilah yang dipilih IBM® pada tahun 1981 sebagai
jantung personal computer IBM PC.
• Versi lanjutan 8088 adalah 80188; lanjutan 8086 adalah 80186, 80286, 80386, 80486, Pentium (atau 586),
PentiumPro (atau 6x86) masing2 dengan tambahan operasi2 dan processing power.
• Setiap keluarga prosesor memiliki kelompok instruksi sendiri2 yang unik yang dipakai untuk memerintah
operasi2nya, seperti menerima input dari keyboard, menampilkan data di layar, dan melakukan aritmetika.
Kelompok instruksi ini dikenal sebagai Bahasa Mesin sistem, yangmana cukup rumit dan agak kabur untuk
mengembangkan software. Itulah sebabnya Penyedia Software membuat Bahasa Assembly untuk tiap
keluarga prosesor yang mewakili beragam instruksi dalam kode simbolik yang lebih mudah dipahami.
• Bahasa Tingkat Tinggi seperti C dan BASIC dirancang untuk menghilangkan kesulitan teknis terkait keterikatan
dengan komputer tertentu (cross-platform), sedangkan Bahasa Assembly Tingkat-Rendah memang dirancang
untuk keluarga prosesor tertentu atau spesifik (platform-dependent).
1) Teknologi CPU elektronik dimulai tahun 1940-an menggunakan tabung vakum. Tabung vakum itu gendut dan menghabiskan banyak listrik. Misalkan,
komputer digital pertama, ENIAC, memerlukan 130.000 watt daya dan menduduki 140 meter persegi. Penemuan transistor pada tahun 1947 mengubah
semuanya, sehingga komputer digital generasi kedua lahir pada tahun 1950-an ditandai dengan produk skala besar IBM 7070, DEC PDP-1, PDP-6, PDP-7 dst.
2) 8080 adalah µP 8-bit, sedangkan 8086 adalah µP 16-bit. 8088 adalah variasi dari 8086 (16-bit) tetapi I/O nya kompatibel dengan 8080 atau 8-bit. Ini
menyebabkan ia mampu terhubung dengan piranti2 8-bit terutama memori yang pada saat itu harganya masih sangat mahal mendominasi harga PC.
Latar Belakang Mengapa Belajar Assembly
• Bahasa Assembly merupakan Bahasa pemrograman tertua dari semua
bahasa pemrograman, yang memiliki kesesuaian paling alami dengan
Bahasa Mesin. Untuk berinteraksi dengan Bahasa Mesin digunakan
bentuk perantara numerik berupa heksadesimal mengingat sulitnya
bermain dengan biner.
Bahasa Assembly Bahasa Biner Mesin
SUB AX, BX 001010111000011
MOV CX, AX 100010111001000
MOV DX, 0 10111010000000000000000

• Bahasa Assembly memberi akses langsung ke hardware komputer

sehingga Anda mampu memahami lebih dalam arsitektur dan sistem
operasi komputer.
 APA YANG AKAN KITA PELAJARI
• Pelajaran diambil dari arsitektur terkemuka dalam pasar komputasi (x86 dan x86_64)
yang disediakan oleh Intel® dan AMD®. Dengan pengetahuan ini dapat mudah
mempelajari arsitektur yang lain.
• Pelajaran dimulai dengan pemahaman beberapa teori dasar yakni arsitektur hardware
(prosesor, memori, register, pengalamatan), pengenalan sistem operasi DOS, konversi
antar bilangan (desimal – heksadesimal – biner), dilanjutkan dengan akses ke hardware
lewat DEBUG.COM dan Bahasa Mesin. Itulah sebabnya perlu mengerti heksadesimal.
• Semakin rumit aplikasi, maka diperlukan bahasa yang tingkatannya lebih tinggi yakni
Bahasa Assembly. Dalam kerangka membangun aplikasi fenomenal (pada jamannya)
DskPatch1), pemahaman mengenai arsitektur komputer dibangun secara alami karena
aplikasi perlu mengakses aritmetika CPU, akses memori (untuk data, program dan stack)
dan akses Input/Output (layar, keyboard, floppy disk).
• Pemahaman pemanfaatan sumberdaya komputer lewat INT (Interrupt) ke DOS maupun
BIOS sehingga kita tidak perlu membangun semua prosedur dari ground-up juga
diperkenalkan secara bertahap. Kita dapat merasakan kealamian membangun sebuah
software. Sumberdaya itu dinamakan fungsi untuk membedakan dengan prosedur
buatan sendiri (dipanggil lewat instruksi !"##).
• Untuk kemudahan pemahaman maka pelajaran menggunakan MASM 6.15 yang masih
16-bit dan simulator EMU8086 4.08.
Sumber:
https://winworldpc.com/home
https://www.4shared.com/rar/wa8iHotqce/emu8086_408.html

1) John Socha and Peter Norton ASSEMBY LANGUAGE FOR THE PC, Third Edition, Brady Publishing, ISBN 1-56686-106-5 (c) 1992
BEBERAPA ALASAN BELAJAR BAHASA ASSEMBLY
• Karena tidak ada lapisan magis antara Anda (yang memakai Bahasa Assembly) dengan mesin, maka
Anda perlu mengerti benar arsitektur (VAX, Motorola 680000, Intel x86, ARM, dst.) dan sistem
operasi komputer sehingga nantinya mampu menopang teknik lanjutan dunia komputer.
• Agar mampu menulis lebih baik dalam Bahasa Tingkat Tinggi, Anda perlu memahami bagaimana,
memori, address dan instruksi bekerja di tingkat bawah. Banyak kesalahan pemrograman tidak
mudah ditemukan di tingkat tinggi; seringkali perlu menyelesaikannya dengan “menggali” internal
program untuk menemukan mengapa ia tidak bekerja. Ini dilakukan pada tingkatan Bahasa Assembly
hasil kompilasi.
• Faktanya semakin kompleks bahasa high-level, akan makin banyak ADT (abstract data type), tentunya
akan butuh lebih banyak overhead untuk mendukungnya. Dalam hal .NET, ada MSIL (Microsoft’s
Intermediate Language); Java memiliki Java Byte Code. Di sinilah Bahasa Assembly bersinar dimana ia
cocok untuk optimisasi speed. Semua tentang performansi dan efisiensi.
• Bahasa Assembly menyediakan kontrol penuh atas sumber daya sistem (register, memori, device dst.)
sehingga cocok untuk dipakai membangun device drivers, low-level embedded systems dan sistem
real-time.
• Bahasa Assembly merupakan batu penjuru pendidikan programmer, gerbang ke beberapa metodologi
pemrograman penting lainnya seperti teknik konstruksi dan algoritma compiler, teknik program
generation, decompilation, reverse engineering dan metode lain yang memerlukan pengetahuan
program biner. Dr Nikolai Bezroukov (www.softpanorama.org) berani mengatakan:
“Without solid base of assembler language programming, the whole building of programmer education is
built on sand”. .... http://www.softpanorama.org/Lang/assembler.shtml
• Donald Knuth, pengarang seri buku The Art of Computer Programming mengatakan:
“Some people [say] that having machine language, at all, was the great mistake that I made. I really don’t
think you can write a book for serious computer programmers unless you are able to discuss low-level
detail.”
 Bahasa Tingkat Tinggi
• Bahasa Tingkat Tinggi adalah bahasa yang statement nya menyerupai
Bahasa Inggris.
• Contoh dalam Bahasa Tingkat Tinggi C++:
English-likeness C++
if (this is true) { 56 (7 == 9) {
peform this series of actions :;<= << “@ ABC D AEF =ℎF HAIF”;
} }
else { FLHF {
perform this series of actions :;<= << “@ ABC D AEF C566FEFB=”;
} }
• Bahasa Tingkat Tinggi dan abstraksi yang disediakannya tentu sangat
berguna bagi manusia, tetapi statement2 harus diterjemahkan dari
Tingkat Tinggi ke Tingkat Mesin agar dapat dieksekusi oleh komputer.
• Lihat ....... Translation Pipeline (Pipa Saluran Penerjemahan).
Sumber:
Brian R. Hall dan Kevin J. Slonka, “Assembly Programming and Computer Architecture for Software Engineer”. © 2018 Prospect Press, Inc.
ISBN: 978-1-943153-32-9
 Translation Pipeline
• Program yang ditulis dalam Bahasa tingkat-tinggi harus ditranslasi atau High-Level
diterjemahkan ke dalam tingkat yang lebih rendah.
Language
• Translasi dilakukan lewat dua cara:
1.Interpreter, dimana translasi dilakukan baris-per-baris ketika program eksekusi,
contoh Bahasa Interpreter Tingkat-Tinggi: Python
2. Compiler, dimana translasi seluruh kode dilakukan sekali langkah sebelum eksekusi,
contoh Bahasa Compiler Tingkat-Tinggi: C++
• Statement bahasa tingkat-tinggi seperti !"# $ = & + 2; memiliki relasi one- Assembly
to-many dengan Bahasa Mesin; artinya satu statement bahasa tingkat-tinggi Language
berpasangan dengan beberapa instruksi Assembly dan Mesin.
• Assembly merupakan bentuk intermediasi (perantara) dalam translation decoding encoding
pipeline (pipa saluran translasi). Program Tingkat-Tinggi diterjemahkan ke
Assembly; selanjutnya Assembly diterjemahkan ke Bahasa Mesin berdasarkan
Instruction Set Architecture (ISA) dari prosesor. Proses dimana kode Assembly Machine
diterjemahkan menjadi Bahasa Mesin disebut encoding; proses kebalikannya Language
disebut decoding.1)
• Statement Bahasa Assembly memiliki relasi one-to-one dengan Bahasa
Mesin; artinya setiap instruksi Bahasa Assembly berpasangan dengan satu
instruksi Bahasa Mesin . Instruksi Bahasa Mesin dinyatakan dalam bentuk
perantara numerik (intermediate numeric form) yakni heksadesimal yang
berikutnya diterjemahkan dan diwujudkan secara fisik sebagai biner pada Digital Logic
hardware, yang kita sebut digital logic.
1) Beberapa compiler seperti Microsoft C Compiler langsung menerjemahkan kode tingkat-tinggi ke bahasa mesin dan membuat Assembly sebagai opsi.
Compiler lainnya seperti GCC menerjemahkan ke Bahasa Assembly lebih dulu, lalu kode Assembly diterjemahkan ke kode mesin.
Instruction Set Architecture
(ISA)
• Instruction Set Architecture (ISA) adalah aspek
arsitektur komputer yang terkait pemrograman.
• ISA memerinci instruksi2, register2, arsitektur
memori, data type dan atribut2 lain sesuai
prosesor tertentu. ISA bisa dibayangkan sebagai
bahasa komputer bercakap-cakap. Seperti terlihat
dalam gambar, ISA memfasilitasi komunikasi antara
software dan hardware.
• Dua jenis ISA:
1. Arsitektur Complex Instruction Set Computing (CISC) memiliki instruksi2 yang panjangnya (dalam
byte) beragam dan kompleks dalam arti satu instruksi tunggal mampu melakukan lebih dari satu task
(misal: mengakses lokasi memori dan melakukan aritmetika).
2. Arsitektur Reduced Instruction Set Computing (RISC) dimana semua instruksi sama panjang dan
hanya melakukan satu task (misal: mengakses lokasi memori).
• x86 dan x86_64 berarsitektur CISC. Intel dan AMD berbeda dalam implementasi tingkat
microarchitecture; mereka memiliki ISA yang sama.
Konsep CISC sudah hadir sejak 1960-an pertama kali diwakili oleh produk seperti IBM System z mainframe, PDP-8, PDP-10, PDP-11, Burroughs B5000, VAX,
Zilog Z80k, MOS Technology 6502, Motorola 68k dan x86. RISC hadir tahun 1980-an diwakili oleh DEC Alpha, AMD 29k, ARC, ARM, Atmel AVR, Blackfin, Intel
i860 dan i960, MIPS, Motorola 8800, PA-RISC, Power dan PowerPC, SuperH dan SPARC.
 Proses Translasi (Penerjemahan)
Contoh Instruksi Assembly di-encode menjadi bahasa mesin Intel 32-bit
Tingkat Bahasa Kode
Bahasa C++ sum = 5;
Tingkat Tinggi
Bahasa GNU Assembler, AT&T syntax movl $0x5, -0x8(%ebp)
Assembly
Bahasa Mesin IA-32 C745F805000000
Digital Logic Binary (implementasi fisik) 1100 0111 0100 0101 1111 1000 0000 0101 0000
0000 0000 0000 0000 0000
• Bahasa Mesin adalah numerik sehingga Anda perlu memahami sistem bilangan terutama heksadesimal dan
biner.
• Bahasa Mesin spesifik terhadap prosesor. Akan tetapi dalam satu keluarga prosesor punya bahasa mesin
yang umum (common) sehingga kode yang ditulis untuk prosesor x86 atau x86_64 bisa jalan pada prosesor
mana saja asalkan bagian keluarga itu.
• Kode Assembly tidak portabel antar keluarga prosesor berbeda. Misalkan kode ditulis untuk keluarga
prosesor x86 tidak akan jalan pada prosesor2 seperti SUN Sparc, IBM 370 dan ARM Cortex.
• Keluarga prosesor x86 / x86_64 termasuk prosesor2 Intel (seperti Pentium, Core-Duo, dan Core i7), dan
prosesor2 AMD (seperti Athlon, Phenom, dan Opteron). Baik Intel maupun AMD menerapkan x86
instruction set dalam desain prosesor mereka, tetapi teknik desain prosesor yang dipakai untuk
menerapkan instruction set yang dikenal sebagai microarchitecture jelas2 sangat berbeda.
• Ketika RISC pertama kali dikembangkan, semata-mata disebabkan akses memori dan HDD sangat
lambat. Complex Instructions yang gendut yang ada dalam CPU x86 model lama sangat
membebani. Itulah sebabnya komputer seperti MAC dan Compaq yang berbasiskan DEC Alpha
jauh meninggalkan sistem Intel dan AMD x86 saat itu. Akan tetapi, sejak Intel mengeluarkan
Pentium III dan AMD mendorong Athlon, terlihat x86 mulai melewati RISC di pasar workstation
dan server. Ini disebabkan adanya perbaikan besar-besaran dalam hal efisiensi caching dan
memori pada CPU x86. Setelah bagian ini diperbaiki, bagian lain dari CPU dengan mudah disetél
(tune) untuk menandingi RISC dan dalam waktu singkat CPU RISC menghilang dari arus utama
komputasi.

Mikroprosesor RISC IBM PowerPC 601

• Namun pada tahun 2013 dari dunia mobile, ARM mengusung kembali RISC dengan konsep ARM-
based SoC (System on Chip). Konsepnya cukup sederhana yakni membangun suatu device yang
kecil, efisien energi yang mampu memanfaatkan memori dan siklus prosesor seefisien mungkin.
Ini juga yang sedang dicoba oleh pabrikan x86. Akan tetapi mengapa lebih banyak pabrikan
mendukung ARM-based SoC dibanding x86? Semata-mata ini disebabkan masalah lisensi.
Pertempuran sudah dimulai dan akan makin memanas. ARM akan berusaha dari dunia mobile
merasuk ke desktop bahkan jika dimungkinkan ke dunia workstation dan server. Tentunya Intel
tidak akan diam begitu saja. Mari kita lihat pertarungan teknologi abad 21 yang seru ini.
 Sisi Perangkat Keras
Mikroprosesor, Register dan Memori
I/O Interface

Intel 8086 CPU die image

Intel 4004 Intel 8008 Intel 8080 Intel 8086 Intel 8088 Intel 80286 Intel 80386 Intel 80486

Arsitektur Prosesor Intel®
• Keluarga CPU Intel® dikelompokkan sebagai mesin berarsitektur Von Neumann.1)
• Terdiri dari 3 blok pembangun: central processing unit
(CPU), memori, dan piranti I/O.
• Ketiga komponen tersambung menggunakan system bus
(terdiri dari address bus, data bus, dan control bus).
• CPU berbicara dengan memori dan piranti I/O dengan menaruh nilai numerik pada
address bus untuk memilih sebuah lokasi memori atau lokasi device port, masing2
punya address numerik yang unik. Lalu CPU, memori, dan piranti2 I/O melalukan
data sesama mereka dengan menaruh data pada data bus. Control bus berisi
sinyal2 yang menentukan arah lalulintas data (ke/dari memori dan ke/dari piranti
I/O).
1) Arsitektur komputer lainnya bernama Arsitektur Harvard memisahkan penyimpanan
(storage) dan jalur lintas (bus) instruksi dengan storage dan bus data. Dengan demikian
diperlukan memory register untuk instruksi dan memory register lainnya untuk data.
Arsitektur Harvard lebih rumit tetapi saluran yang terpisah menghilangkan kemacetan
(bottleneck) yang mungkin terjadi pada Arsitektur Von Neumann.
VKRZQLQ)LJXUHZKHUHWKHFRQGXFWLYHFKDQQHOVDSSHDUDVDOLJKWHUFRORUGXHWRWKHSUHVH
FRSSHUEHWZHHQWKHOD\HUVRIILEHUJODVV
7KHPDLQEXVLQDFRPSXWHUVKRZQLQ)LJXUHLVWKHV\VWHPEXVZKLFKLVDFWXDOO\DFROOHF
WKUHHVHSDUDWHEXVHVWKHGDWDEXVWKHDGGUHVVEXVDQGWKHFRQWUROEXV7KHV\VWHPEXVLVKR
&38FRPPXQLFDWHVZLWKPHPRU\DQGRWKHU,2GHYLFHVLQDFRPSXWHU6XFKFRPSRQHQWVFRQ
HDFK RI WKH WKUHH EXVHV VR SURSHU FRPPXQLFDWLRQ FDQ RFFXU 7KH GDWDEXV LV WKH EXV WKDW WUD
LQVWUXFWLRQV VXFKDVORDGIURPPHPRU\VWRUHLQPHPRU\UHDGIURPWKHRSWLFDOGULYHHWF DQ
EHWZHHQ FRPSRQHQWV ,Q RUGHU IRU LQIRUPDWLRQ WR EH WUDQVIHUUHG WKH FRUUHFW PHPRU\ DGGUHVV
LQVWUXFWLRQVDQGRUGDWDPXVWDOVREHVHQW&RPPXQLFDWLRQRIDGGUHVVHVLVWKHSXUSRVHRIWKHD
EXV 7KH FRQWUROEXV KDV DQ HTXDOO\ LPSRUWDQW UROH LQ WKH FRPPXQLFDWLRQ RI V\VWHP FRPSRQH
WUDQVIHUV VLJQDOV EHWZHHQ FRPSRQHQWV WR HQVXUH WKDW WKH\ DUH V\QFKURQL]HG IRU DSSURSULDWHO\
FRPPXQLFDWLRQ HJRQHFRPSRQHQWGRHVQRWWU\WRUHDGIURPDGHYLFHWKDWLVEXV\ 
)LJXUH6\VWHPEXV
,QDGGLWLRQWRWKHV\VWHPEXVFRPSRQHQWFRPPXQLFDWLRQUHTXLUHVDQRWKHUSX]]OHSLHFH:L
FRPSRQHQWDFWLQJDVDQRSHUDWLRQDOPHWURQRPH DPHWURQRPHLVDGHYLFHWKDWKHOSVPXVLFLDQV
FRQVLVWHQW UK\WKP ZKLOH SHUIRUPLQJ E\ ³WLFNLQJ´ WKH EHDW  FRPSRQHQWV FRXOG VHQG GDWD DFUR
EXVHV DW UDQGRP LQWHUYDOV ZKHWKHU RU QRW WKH FRPSRQHQW RQ WKH RWKHU HQG LV UHDG\ RU D
FRPPXQLFDWH 7KH V\VWHP FORFN D PRWKHUERDUG FRPSRQHQW VROYHV WKH FRPPXQLFDWLRQ SUREO
SXOVLQJDWDFRQVWDQWUDWHHVVHQWLDOO\NHHSLQJWLPHIRUFRPSXWHUFRPSRQHQWV
 Sekilas Prosesor Intel®
• 8088/80188. Prosesor2 ini memiliki register2 16-bit, data bus 8-bit dan mampu mengalamatkan sampai
1 mega byte memori internal. Sekalipun register2 mampu memproses 2 byte sekaligus, data bus hanya
mampu mengirim 1 byte saja. 80188 disajikan sama dengan 8088 dengan sedikit tambahan instruksi.
Prosesor2 ini bekerja dalam apa yang dikenal sebagai real mode, yakni satu program pada satu waktu.
• 8086/801861). Prosesor2 ini mirip dengan 8088/80188, tetapi data bus 16-bit dan mampu bekerja lebih
cepat. 80186 disajikan sama dengan 8086 dengan tambahan sedikit instruksi.
• 80286. Prosesor2 ini bekerja lebih cepat dibanding prosesor2 pendahulunya dan mampu
mengalamatkan sampai 16 mega byte. Ia dapat beroperasi baik dalam real mode (kompatibel dengan
8088/8086) maupun dalam protected mode untuk multitasking (menjalankan lebih dari satu job pada
satu waktu) dan menangani memori sampai 16MB.
• 80386. Prosesor ini memiliki register2 32-bit dan data bus 32-bit serta mampu mengalamatkan sampai 4
giga byte memori. Ia mampu beroperasi baik dalam real mode maupun protected mode (menjaga
kompatibilitas dengan 80286) untuk multitasking, dan tambahan satu lagi: virtual mode sehingga
mampu menangani memori sampai 4GB.
• 80486. Prosesor ini juga memiliki register2 32-bit dan data bus 32-bit (walaupun beberapa clones punya
data bus 16-bit) dan dirancang untuk peningkatan kinerja. Prosesor ini masih banyak dipakai sampai
sekarang sebagai jantung peralatan kontroler seperti kontroler2 aviasi di pesawat terbang.
• Pentium (atau 80586). Prosesor ini memiliki register2 32-bit dan data bus 64-bit serta mampu
mengeksekusi lebih dari satu instruction per clock cycle (Intel mengadopsi nama “Pentium” karena,
berbeda dengan angka, nama dapat dibuat hak cipta).
• PentiumPro (atau 6x86). Prosesor ini lebih jauh meningkatkan kapasitas register2 dan data bus.
Contohnya dimana koneksi prosesor terdahulu ke storage cache pada system board menyebabkan
delays (tundaan), prosesor ini dikoneksikan ke sebuah storage cache yang built-in lewat 64-bit wide bus .
1) Intel membuat prosesor 8085 (Maret 1976) lebih dahulu sebelum 8086. 8085 masih 8-bit tetapi mampu melakukan operasi2 data 16-bit. 8085 banyak
diterapkan untuk terapan mikrokontroler karena built-in serial I/O dan 5 prioritized interrupts. Prosesor ini menyelamatkan Intel dalam persaingan komputer
desktop berbasis CP/M yang saat itu mayoritas dikuasai CPU dari Zilog z80. Zilog didirikan oleh mantan pegawai Intel, Federico Faggin, tahun 1974.
Evolusi Mikroprosesor Intel
Product 8080 8085 8086 8088 80286 80386 80486
Tahun diperkenalkan 1974 1976 1978 1979 1982 1985 1989
Clock rate (MHz) 2–3 3–8 5 – 10 5–8 6 – 16 16 – 33 25 – 50
Jlh. transistor 4500 6500 29.000 29.000 130.000 275.000 1.2 juta
Memori Fisik 64K 64K 1M 1M 16M 4G 4G
Internal data bus 8 8 16 16 16 32 32
External data bus 8 8 16 8 16 32 32
Address bus 16 16 20 20 24 32 32
Data type (bits) 8 8 8, 16 8, 16 8, 16 8, 16, 32 8, 16, 32

Catatan:
1. Arsitektur 80386SX sama dengan 80386 kecuali external data bus nya 16 bit dalam SX bukan 32 bit, dan
address bus nya 24 bit bukan 32; oleh karena itu memori fisiknya 16MB.
2. Clock rate berada di sekitaran rate saat produk diperkenalkan; beberapa rate telah meningkat selama
waktu ini.
Perbedaan Antara Intel® Core i3, i5 dan i7
• Awalnya perlombaan dalam clock speed untuk mengejar
work per cycle. Akan tetapi sekarang berlomba menggunakan
Core (pertama diperkenalkan oleh AMD)
• i3 datang dengan Hyper-Threading
• i5 memiliki fitur Hyper-Threading dan Turbo boost
• i7 datang dengan 2 sampai 8 core dengan fitur Hyper-Threading, Turbo boosting, dan
kemampuan Overclocking.

• Hyper-Threading adalah teknologi yang memampukan satu prosesor tunggal berlaku seperti dua prosesor
terhadap sistem operasi dan program2 aplikasi yang menggunakannya.
• Intel® Turbo Boost Technology mampu mempercepat kinerja prosesor dan grafis mencapai beban puncaknya
(peak loads). Teknologi ini mampu meningkatkan frekuensi Core secara otomatis sehingga jauh lebih cepat
daripada frekuensi yang tercatat seharusnya. Tingkat kecepatan prosesor tersebut bisa bekerja maksimal
dalam batasan daya, suhu, dan spesifikasi dari kekuatan desain termal (TDP). Hasilnya, Anda akan melihat
bagaimana ia bereaksi dalam hal peningkatan kinerja aplikasi tunggal dan multi-threaded.
Arsitektur Prosesor 8086 • Prosesor dipartisi menjadi dua logical units: execution
unit (EU) dan bus interface unit (BIU). Tugas EU adalah
mengeksekusi instruksi2, BIU mengantar instruksi2 dan
data ke EU. EU berisi sebuah arithmetic and logic unit
(ALU), sebuah control unit (CU) dan sejumlah register.
Gabungan ini memampukan prosesor mengeksekusi
instruksi2 dan operasi2 aritmetika dan logika.
• Tugas utama BIU adalah mengelola bus control unit,
segment register dan instruction queue. BIU
mengendalikan bus2 yang mengirim data ke EU, ke
memori dan ke piranti I/O eksternal dimana segment
register mengendalikan pengalamatan memori.
• Tugas lain BIU adalah menyediakan akses bagi
instruksi2. Karena instruksi2 sebuah program yang
sedang eksekusi berada dalam memori, BIU harus
mengakses instruksi2 dari memori dan menaruhnya
dalam instruction queue, yang bervariasi dalam
ukurannya tergantung prosesor. Fitur ini membuat BIU
mampu melihat lebih dulu (look ahead) dan
menjemput lebih dulu (prefetch) instruksi2 sehingga
selalu ada antrian instruksi yang siap untuk dieksekusi.
• EU dan BIU bekerja secara paralel, dimana BIU selalu menjaga satu langkah di depan.
EU mengabarkan BIU kapan ia perlu mengakses data dalam memori atau piranti I/O.
Juga, EU meminta instruksi2 mesin dari antrian instruksi BIU. Instruksi paling atas yang
sedang eksekusi saat ini dan sementara EU diduduki oleh instruksi yang eksekusi, BIU
sudah menjemput instruksi lain dari memori. Penjemputan (fetching) ini tumpang
tindih dengan eksekusi dan ini ”mempercepat” pemrosesan.
• Prosesor2 sampai 80486 dikenal sebagai single-stage pipeline dimana ada
keterbatasan harus menyelesaikan satu instruksi sebelum memulai yang baru.
Pipelining adalah cara sebuah prosesor membagi satu instruksi menjadi beberapa
langkah berturutan dalam rangka menggunakan sumberdaya2 berbeda. Pentium
memiliki five-stage pipelined structure; PentiumPro memiliki 12-stage superpipelined
structure. Fitur inilah yang membuat prosesor seolah2 mampu menjalankan banyak
operasi secara paralel.
• Masalah yang dihadapi perancang adalah karena prosesor bekerja jauh lebih cepat
dari memori, ia mesti menunggu memori menyerahkan instruksi2. Untuk mengatasi
masalah ini, prosesor canggih pada gilirannya memiliki kemampuan lebih dalam
dynamic execution, yang terdiri dari tiga unsur:
1. Multiple branch prediction, dimana prosesor melihat lebih dulu (look ahead) sejumlah langkah
untuk memprediksi apa yang akan diproses berikutnya;
2. Dataflow analysis, yang menganalisis kebergantungan (dependencies) antar instruksi2; dan
3. Speculative execution, yang memanfaatkan hasil dari dua unsur tadi untuk berspekulasi
mengeksekusi instruksi2.
• Sebagai programmer, Anda tidak mungkin mengakses fitur2 prosesor di atas. Sudah
bawaan lahir dari perangkat keras yang tidak bisa disentuh-sentuh.
System Clock
• Bersamaan dengan system bus, komunikasi antar komponen memerlukan potongan puzzle
lainnya. Tanpa komponen yang berlaku sebagai metronom operasional (metronom adalah
alat yang menjaga pemusik agar ritmenya konsisten selama bermain dengan melakukan
“ketukan” atau “dentang” atau “ticking” atau “beat”), komponen2 bisa saja mengirim data
lewat bus2 pada interval waktu yang acak dan komponen pada ujung lain bisa sudah siap
atau belum menerima komunikasi.
• Komponen motherboard yang bernama system clock menyelesaikan masalah komunikasi ini
dengan berdenyut pada laju yang konstan (constant rate), semata2 untuk menjaga waktu
komponen2 komputer.
• Satuan dasar system clock adalah clock cycle yang
terdiri dari up-tick (setengah pertama dari siklus,
dimana tegangan berjalan dari rendah ke tinggi, atau
dalam biner 0 ke 1) dan down-tick (setengah kedua
dari siklus, dimana tegangan berjalan dari tinggi ke
rendah, atau dalam biner 1 ke 0).
)LJXUH&ORFNF\FOH

7KHEDVHXQLWIRUWKHV\VWHPFORFNLVDFORFNF\FOHZKLFKFRQVLVWVRIDQXSWLFN WKHILUVWKDOIRIWKH
F\FOHZKHUHWKHYROWDJHJRHVIURPORZWRKLJKRULQELQDU\WR DQGDGRZQWLFN WKHVHFRQGKDOI
RIWKHF\FOHZKHUHWKHYROWDJHJRHVIURPKLJKWRORZRULQELQDU\WR )LJXUHVKRZVDFORFN
F\FOH
'DWDWUDQVIHURSHUDWLRQVUDLVHWKHLVVXHRIGDWDDQGLQVWUXFWLRQVWRUDJH,QRUGHUWRVWRUHGDWDDQG
LQVWUXFWLRQVDFRPSXWHUPXVWKDYHPHPRU\:KHQGLVFXVVLQJPHPRU\ZHPXVWEHFOHDUDERXWZKLFK
W\SHRIPHPRU\LVXQGHUFRQVLGHUDWLRQ:HFDQWKLQNRIWKHGLIIHUHQWNLQGVRIPHPRU\LQDFRPSXWHUDV
DKLHUDUFK\DVGHSLFWHGLQ)LJXUH
(Untuk Referensi Saja)

Intel A80386DX-20 CPU die image

 PLOOLRQWLFNVSHUVHFRQGDQGELOOLRQWLFNVSHUVHFRQGUHVSHFWLYHO\7RH[SUHV
WKHFORFNF\FOHUDWHUDWKHUWKDQWKHSURFHVVRUIUHTXHQF\ZHWDNHWKHUHFLSURFDORI
WKHIUHTXHQF\LV*+] ELOOLRQWLFNVSHUVHFRQG HDFKFORFNF\FOHZRXOGEHE
LQ GXUDWLRQ $Q LPSRUWDQW QRWH LV WKDW WKH VSHHG DW ZKLFK WKH &38 FORFN WLFNV
V\VWHPFORFNVSHHGZKLFKLVGHWHUPLQHGE\WKHPXOWLSOLHU)RUH[DPSOHLIDV\VW
DW0+]DQGWKHPXOWLSOLHULVWKHQWKHIUHTXHQF\RIWKH&38ZLOOEH*+]
UXQQLQJIRXUWLPHVIDVWHUWKDQWKHV\VWHPFORFNDQGFDQSHUIRUPIRXUWLPHVWKHQXP
Tentang Prosesor WKHVDPHDPRXQWRIWLPH

• Bayangkan CPU atau prosesor sebagai otak komputer. CPU

merupakan komponen yang menangani operasi2 aritmetika dan
logika. Empat komponen utama CPU adalah: Arithmetic Logic Unit
(ALU), Control Unit (CU), CPU clock dan memori
(cache dan register2).
• ALU adalah sub komponen matematis CPU yang melakukan
operasi2 aritmetika dan logika atas operand2 integer (Operand2
integer adalah kunci pembeda; masih ada komponen lain yang
)LJXUH&38FRPSRQHQWV
bertanggung jawab atas operasi2 pada operand2 floating-point).
• CU bertanggung jawab mengarahkan aliran data dalam CPU, memastikan semua sub
komponen lain dari CPU menerima data yang benar pada waktu yang benar dan bertindak
yang sesuai.
• Instruksi2 CPU yang bergantung atas banyak sub-tasks agar dapat berjalan yang sesuai,
mengikuti Instruction Execution Cycle yang dikomandoi oleh CU. CPU clock, berbeda dengan
system clock, merupakan clock dari CPU itu sendiri yang menjaga waktu bagi operasi2 CPU.
• Kecepatan dari CPU clock dinamakan frekuensi yang diukur dalam Hertz.
Sederhananya jika sebuah prosesor punya frekuensi 1 Hertz (Hz), artinya clock
berdentang satu kali per detik. Dentang atau ticking adalah satu osilasi penuh
(sebuah up-tick dan down-tick).
• Prosesor modern diukur dalam megahert (MHz) atau gigahertz (GHz), yang
berarti masing2 1 juta tick per detik dan 1 milyar tick per detik. Untuk
membayangkannya dalam terminologi clock cycle (diukur dalam satuan waktu),
bukan frekuensi prosesor, kita bisa ambil kebalikan dari frekuensi. Maka fekuensi
1 GHz sama dengan durasi setiap clock cycle sepermilyar detik.
• Hal lain yang perlu diperhatikan adalah kecepatan dimana CPU clock berdentang
(ticking) bisa merupakan kelipatan kecepatan system clock yang ditentukan oleh
multiplier. Misalkan system clock berjalan pada 800MHz dan multipliernya 4,
maka frekuensi CPU
menjadi 3.2GHz. CPU
clock berjalan empat
kali lebih cepat
daripada system clock
dan mampu melakukan )LJXUH&ORFNF\FOH

empat kali jumlah operasi dalam waktu yang sama.

7KHEDVHXQLWIRUWKHV\VWHPFORFNLVDFORFNF\FOHZKLFKFRQVLVWVRIDQXSWLFN WKHILUVWKDOIRIWKH
F\FOHZKHUHWKHYROWDJHJRHVIURPORZWRKLJKRULQELQDU\WR DQGDGRZQWLFN WKHVHFRQGKDOI
RIWKHF\FOHZKHUHWKHYROWDJHJRHVIURPKLJKWRORZRULQELQDU\WR )LJXUHVKRZVDFORFN
F\FOH
'DWDWUDQVIHURSHUDWLRQVUDLVHWKHLVVXHRIGDWDDQGLQVWUXFWLRQVWRUDJH,QRUGHUWRVWRUHGDWDDQG
LQVWUXFWLRQVDFRPSXWHUPXVWKDYHPHPRU\:KHQGLVFXVVLQJPHPRU\ZHPXVWEHFOHDUDERXWZKLFK
W\SHRIPHPRU\LVXQGHUFRQVLGHUDWLRQ:HFDQWKLQNRIWKHGLIIHUHQWNLQGVRIPHPRU\LQDFRPSXWHUDV
DKLHUDUFK\DVGHSLFWHGLQ)LJXUH
 WRDGGUHVVXSWR7%RI5$0DKXJHLPSURYHPHQWRYHUWKH*%PD[LPXPRIDELWSURFHVVRU

Eksekusi Instruksi ,Q DGGLWLRQ WR EHLQJ DEOH WR DGGUHVV PRUH 5$0 [B SURFHVVRUV DOVR KDYH HLJKW PRUH JHQHUDO
SXUSRVHUHJLVWHUVUWKURXJKU

• Agar sebuah instruksi dieksekusi (mis. ADD), urutan langkah2 yang dikenal sebagai instruction
,QVWUXFWLRQ([HFXWLRQ
execution cycle perlu diikuti. Bagi programmer instruksi ADD seperti proses satu-langkah, tetapi
prosesor membaginya menjadi sub-tasks,,QRUGHUIRUDQLQVWUXFWLRQWREHH[HFXWHG
atau stages (atau tahapan),HJ$'' DVHTXHQFHRIVWHSVNQRZQDVWKHLQVWUXFWLRQ
yang berisi eksekusi instruksi.
Jumlah stages beragam dari sedikitnyaH[HFXWLRQF\FOHLVIROORZHG$OWKRXJKWKH$''LQVWUXFWLRQLVRQO\RQHLQVWUXFWLRQDQGPLJKWVHHPOLNH
tiga stages pada level abstrak sampai 20 atau lebih ditemukan
dalam prosesor high-end modern.D RQHVWHS SURFHVV WR
Jadi ketika D SURJUDPPHU PDQ\
programmer VPDOOHUinstruksi
menulis VXEWDVNV RUADD
VWDJHV untuk
FRPSULVH LQVWUXFWLRQ
H[HFXWLRQterjadi
menjumlahkan dua bilangan, ada 20 langkah 7KH QXPEHU RI VWDJHV FDQlayar
di belakang YDU\ IURP
yang DVbergerak
IHZ DV WKUHHsesuai
VWDJHV DWexecution
DQ DEVWUDFW OHYHO )LJXUH
 WRXSZDUGVRIRUPRUHVWDJHVLQPRGHUQKLJKHQGSURFHVVRUV
cycle agar supaya menghasilkan penjumlahan.
• View yang umum dari cycle tersebut
adalah tiga langkah: Fetch, Decode dan
Execute. Selama tahapan Fetch, CPU
mengambil (retrieve) instruksi berikutnya
yang akan dieksekusi (yakni dari penunjukkan
RIP/EIP/IP ke memori). )LJXUH6WDJHLQVWUXFWLRQH[HFXWLRQF\FOH
• Pada tahapan Decode, CPU menentukan instruksi apa itu dan data apa yang ia operasikan. Selama
6RZKHQDSURJUDPPHUZULWHVWKH$''LQVWUXFWLRQWRFRPSXWHWKHVXPRIWZRYDOXHVVWHSVPD\
tahapan ini, CPU melihat bit2 instruksi (0 dan 1) dan mampu menentukan jenis operasi (yakni ADD,
RFFXUEHKLQGWKHVFHQHVWRSURFHHGWKURXJKWKHH[HFXWLRQF\FOHLQRUGHUWRSURGXFHWKHVXP
SUB, MOV) dan apakah perlu tidaknya $operasiFRPPRQ KLJKOHYHO
menyertakan YLHZ RI operand2.
WKH F\FOH LV VHHQ
JikaDV WKUHH
operasiVWHSVmemerlukan
)HWFK 'HFRGH DQG ([HFXWH
operand2, CPU juga perlu menjemputnya 'XULQJWKH)HWFK
(fetch) juga. VWDJH WKH &38 UHWULHYHV WKH QH[W LQVWUXFWLRQ WR EH H[HFXWHG LH ZKHUH ULSHLS LV
SRLQWLQJ LQ PHPRU\  ,Q WKH 'HFRGH VWDJH WKH &38 GHWHUPLQHV ZKDW WKH LQVWUXFWLRQ LV DQG RQ ZKDW
• Setelah seluruh data yang diperlukan GDWDLWRSHUDWHV'XULQJWKH'HFRGHVWDJHWKH&38ORRNVDWWKHELWVRIWKHLQVWUXFWLRQ
dijemput (fetched) dan di-decode, CPU dapat Execute instruksi.VDQGV DQG
Apabila ada hasil, seperti halnya instruksi ADD dan SUB, CPU akanHJ$''68%029
LVDEOHWRGHWHUPLQHWKHW\SHRIRSHUDWLRQ menyimpan (store) hasil pada
DQGZKHWKHURUQRWWKHRSHUDWLRQ
tempat yang sesuai (yakni Register, Memori).
LQFOXGHVRSHUDQGV,IWKHRSHUDWLRQLQFOXGHVRSHUDQGVWKH&38PD\QHHGWRIHWFKWKRVHDVZHOO2QFH
DOOQHFHVVDU\GDWDLVIHWFKHGDQGGHFRGHGWKH&38FDQ([HFXWHWKHLQVWUXFWLRQ6KRXOGWKHRSHUDWLRQ
SURGXFH D UHVXOW DV ZLWK WKH $'' DQG 68% LQVWUXFWLRQV WKH &38 ZLOO VWRUH WKH UHVXOW LQ WKH
DSSURSULDWHSODFH HJUHJLVWHUPHPRU\ 

3LSHOLQLQJ
,QPRGHUQSURFHVVRUVHDFKSDUWRIWKHVWDJHF\FOHFDQFRQWDLQVXEVWHSV3URFHVVRUDUFKLWHFWVKDYH
IRXQGRYHUWKH\HDUVWKDWRYHUODSSLQJWKHVWDJHVRIWKHF\FOHUHVXOWVLQEHWWHUSHUIRUPDQFHEHFDXVHWKH
 Pipelining
• Pada prosesor modern, setiap 3-stage cycle bisa terdiri atas sub-steps. Arsitek2 prosesor beberapa
dekade belakangan ini menemukan bahwa menumpang tindih stage2 dalam cycle bisa menghasilkan
kinerja lebih baik karena prosesor bisa bekerja menjemput instruksi kedua saat bergerak men-decode
instruksi pertama dst. Rancangan tumpang tindih ini dinamakan pipelining.
HFRQGPHWKRGLVWKHEHVWXVHRI\RXUWLPH7KHODXQGU\H[DPSOHLOOXVWUDWHVWKHFRQFHSWRISLSHOLQLQJ
&38ZLWKVHSDUDWH)HWFK'HFRGHDQG([HFXWHXQLWVPD\QRWEHDEOHWRSHUIRUPWKUHHIHWFKHVDWWKH
• Superpipeline adalah pipeline sampai 20 tahapan. CPU mampu bekerja dengan 20 langkah berbeda
DPHWLPHEXWLWFDQSHUIRUPD)HWFKD'HFRGHDQGDQ([HFXWHVLPXOWDQHRXVO\'RLQJVRLVDEHWWHU
VHRIDSURFHVVRU¶VWLPHDQGUHVXOWVLQEHWWHUSHUIRUPDQFH
sekaligus, dimana instruksi2 berada dalam tahapan2 berbeda. Makin banyak tahapan pipeline yang
dipakai CPU, makin banyak kerja yang diselesaikan CPU dalam satu rangka waktu. Dengan 20-stage
Instruction Execution Cycle, prosesor tanpa pipeline perlu menunggu semuanya 20 stages instruksi2
untuk selesai yaitu 200 clock cycle untuk menyelesaikan 10 operasi. Prosesor2 20-staged pipelined
$77(17,210RGHUQSURFHVVRUVDFWXDOO\FRQWDLQPXOWLSOH)HWFK'HFRGHDQG([HFXWHXQLWVWR
PD[LPL]HWKURXJKSXWRILQVWUXFWLRQH[HFXWLRQ
mampu mengurangi clock cycle sampai 29, suatu peningkatan kinerja 690%.

)LJXUH3LSHOLQHGLQVWUXFWLRQH[HFXWLRQF\FOH
)LJXUHVWDJHVXSHUSLSHOLQH
$V SUHYLRXVO\ PHQWLRQHG D SLSHOLQH FRXOG KDYH XSZDUGV RI  VWDJHV ZKLFK LV NQRZQ DV D
XSHUSLSHOLQH $ &38 FRXOG EH ZRUNLQJ RQ  GLIIHUHQW VWHSV VLPXOWDQHRXVO\ ZLWK LQVWUXFWLRQV LQ
,QSXWDQG2XWSXW
LIIHUHQWVWDJHV7KHPRUHSLSHOLQHVWDJHVWKH&38XVHVWKHPRUHZRUNFDQEHSHUIRUPHGE\WKH&38
QDVSHFLILFWLPHIUDPH:LWKDVWDJH,QVWUXFWLRQ([HFXWLRQ&\FOHLQDQRQSLSHOLQHGSURFHVVRUD
8SWRWKLVSRLQWZHKDYHGLVFXVVHGWKHSURFHVVRULQVRPHGHWDLODQGKRZLWFRPPXQLFDWHVZLWKRWKHU
PLQLPXPRIFORFNF\FOHVZRXOGEHQHHGHGWRFRPSOHWHRSHUDWLRQVEHFDXVHHDFKLQVWUXFWLRQ
PDMRU FRPSRQHQWV ORFDWHG RQ WKH PRWKHUERDUG %XW KRZ GRHV WKH SURFHVVRU FRPPXQLFDWH ZLWK
RXOGKDYHWRZDLWIRUDOOVWDJHVRIWKHSUHYLRXVLQVWUXFWLRQWRILQLVK:LWKDVWDJHSLSHOLQHG
Intel® 8086 merupakan prosesor berdesain futuristik jauh ke depan. Ia merupakan prosesor pertama dengan
kemampuan pipeline, berbeda dengan pendahulunya yang belum punya kemampuan itu. Pada sistem dengan
pipeline, data bus dan address bus tetap sibuk (busy) melalulintaskan data sementara CPU memproses
informasi. dengan demikian processing power efektif dari prosesor meningkat.
Memori Internal
• Dua jenis memori dalam PC adalah random access memory (RAM) dan read-only memory
(ROM). Byte2 dalam memori diberi nomor berurutan, mulai dengan 00, sehingga setiap
lokasi memiliki nomor alamat yang unik.
ROM. ROM terdiri dari memory chips khusus yang
hanya bisa dibaca. Karena instruksi2 dan data
secara permanen ditanam ke dalam chips, maka
tidak dapat diubah. ROM Basic Input/Output
System (BIOS) mulai pada alamat 768K dan
menangani seluruh piranti input/output seperti
hard disk controller. ROM mulai dari 960K
mengendalikan fungsi2 dasar komputer seperti
Peta Fisik dari Memori Dasar PC 8086 power-on self-test, pola titik (dot pattern) dari
Dari satu megabyte memori, 640K pertama grafis, dan disk self-loader. Saat Anda tekan tombol
adalah RAM dasar, kebanyakan tersedia
power, ROM melakukan beragam cek dan
untuk Anda pakai
mengangkat (load) special system data dari disk ke
RAM.
RAM. Programmer sangat terkait dengan RAM yang sering dinamakan
“read-write memory”. RAM tersedia sebagai “kertas kerja” untuk
tampungan temporer dan eksekusi program.
Karena isi RAM hilang saat komputer mati (volatile), Anda perlu
tampungan eksternal, terpisah, untuk menyimpan program dan data.
Ketika Anda mematikan komputer, prosedur boot-up ROM mengangkat
(load) sebagian sistem operasi ke dalam RAM. Lalu Anda dapat
memintanya melakukan beberapa aksi, misalnya loading sebuah
program dari disk ke dalam RAM. Program Anda berjalan dalam RAM
dan secara normal berproduksi suatu output ke layar, printer atau disk.
Setelah selesai, Anda bisa meminta sistem untuk loading program
lainnya ke dalam RAM, sebuah aksi yang menimpa (overwrites)
program terdahulu. Seluruh diskusi tentang RAM, selanjutnya kita
gunakan kata “memori”.
 195

• Memori dapat dibayangkan sebagai kue lapis yang 194

masing-masing lapis memiliki label atau alamat lokasi.
193
• Memori menyimpan dalam satuan satu byte per label Double Word at
lokasi. Artinya untuk nilai yang lebih besar dari satu Address 192 192

byte, 8086 menggunakan lokasi memori berikutnya. 191

Address
• Data satu word memerlukan dua lokasi memori; data
190
dua word memerlukan empat lokasi memori.
189
Address = 125 Memory Word at
Address 188 188

Data = 0 Location 187

CPU 125
Byte at
Address 186 186
Write = 0

Figure 1-9: Byte, word, and double-word storage in memory

Operasi Memory Write Address = 125

Memory Operasi Memory Read
Misal : Misal :
Memory[125]:=0; :=Memory[125];
Data = Memory[125] Location
CPU menaruh nilai 0 pada data bus, alamat CPU 125
CPU menaruh alamat 125 pada
125 pada address bus, kemudian memaksa address bus, memaksa (assert) read
(assert) write line pada control bus (biasanya Read = 0 line pada control bus (biasanya
dengan mengeset line menjadi 0). dengan mengeset line menjadi 0)
lalu membaca data dari data bus.
• Prosesor2 80x86 modern tidak lagi langsung terhubung ke memori. Ada memory buffer khusus pada CPU
yang dikenal sebagai cache (dibaca “cash”) yang berlaku sebagai perantara berkecepatan tinggi antara CPU
dan memori utama.
• Walaupun cache menangani detil2nya otomotasi bagi Anda, kenyataannya Anda perlu tahu bahwa mengakses
objek2 data dalam memori lebih efisien jika alamat objek merupakan kelipatan ukuran objek.
• Oleh karena itu ide yang baik untuk mengarahkan objek2
4-byte (double word) pada alamat2 yang kelipatan 4.
Begitu pula objek2 2-byte pada alamat2 genap.
Tentunya cukup efisien mengakses objek2
satu byte pada alamat mana saja.

Hirarki Memori
Pengalamatan Data dalam Memori
• Tergantung modelnya, prosesor dapat mengakses satu atau lebih byte dari memori
pada satu waktu. Anggaplah bilangan desimal 1.315; representasi heksa-nya 0529h,
memerlukan 2 byte atau 1 word memori yang terdiri dari high-order (most significant)
byte, 05, dan low-order (least significant) byte, 29. Sistem menyimpannya dalam
memori dengan urutan terbalik: low-order byte disimpan pada alamat memori bawah
dan high-order byte pada alamat memori atas.

• Saat prosesor mengambil (retrieve) satu

register 05 29
word dari memori, ia kembali membalik
byte, sehingga tersimpan dengan benar di
memory 29 05 register sebagai heksa 05 29.
• Sekalipun fitur ini otomatis, programmer
harus paham ini terutama ketika melakukan
address 7612, address 7613, debugging.
least significant byte most significant byte
Cara Pengalamatan ini terkait dengan arsitektur Little
yang dianut prosesor2 Intel …… lihat Big-Endian vs
Little-Endian

 

/  $%/ # $/ %/ #$$/ $!/ $/   %/ # !# $$ #/
!/ / %/   */ %/ * #/ #$%#$/ #/   %/ # -
!# $$ #/ !/ $/ $/ $#/ % / %/ '$#/  +$/ */ #/ )/
% / , / # / %/  ,/  !#/ % / %/ $ #%/ $/ */ #/

   
  )/
'/ $ /
,/ % / %/ ! $%/ ! ,$/ / $!/ # $/  /
#/ / / %#/ #$$/ $!/ %#,/ '%/ / #/

  %/ #$$/ $!/ #/ $/ $!#%/ / #%/ # / %/ * #/
#$%#/ #/

PENGALAMATAN (ADDRESSING)
%
$/ %/ /  $#/ 

! $%/
/ %/ / / '#/ ! $%/

/ % / %/ %#/ /  %,!/  +/ 

/  +$/ 
/
$$'/ %
$/ / / $/ *$%#/ % */ *#/ )#, ,/  $/ % / %/
$/ / %$/ /

  


















'+ *&+ '"+ + + $+ ##+ + + #$+ + "+ "+
%#+ + # "$#+ $(+ ( %+ #+ + %"+ + ( $+  #+
#+ + %*  + " &$"+
&"+ #$ #$"+ %#+ %+ # + ( *+ + "
#+
 #+ (+ $+
#+ ( %+  + #+ ("+ "+  #+ + )#+ "+ '  +

("+ &#"#+  + + %+ + & + $"+  + *+ "%& "+ )+ %+
/ / / #$$/ $/ /  % / / %/ $/ *%/ $/ /%%/
+ "+ +  *+ "+ + &###+ "+ + &+ "+ "+ + &"+ &#%+ %
#+ *+
/ /#$$/ / / #  !'%#/'$%/ /'"'/ / +.
! "%& "+  $+ + + "
#+ "##+ # +  +  '+ ' "&#+ &##+
(!$/ / /  */ / #$$$/ / %/ #$$/ $!/ #/ %/
&/ ,/ / +/ '#/ / * #/ #$%#$/ #/ '$',/ .
#+  %#+  + + &#+ "+ $ " "*+ "+ " $+ #%" + +
%/ ,/ / #/ ,/ / $/ %%#/
 % + + "" #+ "+ %*+  + $+ *&+  &$+ "+ &$ &$+ $+ $+ " +
("+ Don Lancaster, “Machine Language Programming Cookbook” © 2010


by Synergetics Press.
) !)  ) ) !) !) ) ) #  ) !) ')   ))
!)  ) )  $)  ) !)  ) ) )    
) 

  ) ) ) %) % ) )   )   ! !) ) ")  ) ) # #)
!#) ) ) ') )  )  )  )    )  ) ")
   ) ) ) )    )

    

)  ! ) $) ) ) %  ) )  !  ) ) ")

 ') $) ) ! ')  ) !) #") !#) ) %) )
') $) % ' ) ) ) ! ) ) %) '#) ) ) ) ) )
Big-Endian vs Little-Endian
• Saat berinteraksi dengan memori, programmer perlu sadar metode penyimpanan. Komputer menyimpan data
ke memori dalam potongan2 (chunks) yang spesifik sesuai arsitekturnya (arsitektur x86 menggunakan 32 bit,
x86_64 menggunakan 64 bit) sedangkan nilai disusun dalam byte2. Jika Byte 1 Byte 2 Byte 3 Byte 4
kita simpan nilai heksa 32-bit 12345678h ke memori komputer, nilai 32-bit
ini dipecah menjadi potongan berukuran byte. 12 34 56 78

• Untuk menyimpan sebuah nilai, kita perlu menemukan lokasi memori yang tersedia berikutnya. Demi
kejelasan, anggaplah lokasi memori tersedia berikutnya adalah 0x00000000h. Kita bisa menulisnya ke memori
berturutan dengan nilai2 (per byte) ditulis dari atas ke bawah (yakni most significant byte pada alamat
memori terendah dan least significant byte pada alamat memori tertinggi). Ini dinamakan urutan byte Big-
Endian, yakni “big end” (penghujung besar) disimpan dulu.
• Sebaliknya jika nilai2 (per byte) ditulis dari bawah ke atas, dinamakan urutan byte Little-Endian, yakni “little
end” (penghujung kecil) disimpan lebih dulu.
Alamat Memori Data Alamat Memori Data
• Intel x86 dan x86-64 menggunakan urutan Little-Endian. 0x00000000 78
0x00000000 12
Prosesor Motorola seri 68xx[x], IBM Z series,
menggunakan urutan Big-Endian. Beberapa prosesor 0x00000008 34 0x00000008 56
mampu menggunakan keduanya yang sering 0x00000010 56 0x00000010 34
dinamakan bi-endian, misalkan Sun SPARC, ARM dan 0x00000018 12
0x00000018 78
PowerPC.
Big-Endian Byte Order Little-Endian Byte Order
SHUIRUPLQJ RSHUDWLRQV RQ GDWD D SODFH PXVW H[LVW IRU WKH SURFHVVRU WR VWRUH
QGDGGUHVVHV:HSUHYLRXVO\H[SODLQHGWKDWLQWKHPHPRU\KLHUDUFK\WKHIDUWKHU
 WKH PHPRU\ H[LVWV WKH VORZHU GDWD DFFHVV EHFRPHV ,Q RUGHU IRU WKH &38 WR
VTXLFNO\DVSRVVLEOHLWKDVWREHDEOHWRDFFHVVDQGVWRUHLQVWUXFWLRQVDQGGDWD
H7KXVWKHORFDWLRQRILQVWUXFWLRQVDQGGDWDQHHGVWREHDVFORVHWRWKH$/8DQG
RVH SUR[LPLW\ PHPRU\ ZKLFK LV DFWXDOO\ RQ WKH &38 GLH DORQJ ZLWK WKH ORJLF
V FDFKH :KLOH FDFKH FDQ EH YLHZHG LQ WHUPV RI WKH DIRUHPHQWLRQHG PHPRU\
Cache
KDVDKLHUDUFK\RILWVRZQ
VVRUVFDFKHW\SLFDOO\LVGLYLGHGLQWRWKUHHWLHUVOHYHO / OHYHO / DQG
• Prosesor modern dilengkapi dengan cache yang umumnya terbagi tiga tingkat (three tiers): level 1 (L1), level
FKHKLHUDUFK\IROORZVWKHVDPHSULQFLSOHVDVWKHPHPRU\KLHUDUFK\7KHIDUWKHU
RZHUODUJHUDQGFKHDSHULWEHFRPHV%RWK/DQG/FDFKHDUHYHU\FORVHWRWKH
2 (L2) dan level 3 (L3). Hirarkinya mengikuti prinsip2 yang sama dengan hirarki memori: makin jauh dari
 VOLJKWO\ IDUWKHUALU,
DZD\makin
DQG ODUJHU LQ FDSDFLW\
lambat, makin/ FDFKH
besar KDVdan
EHFRPH W\SLFDO
makin RQ
murah. Baik cache L1 dan L2 sangat dekat dengan ALU, dimana
UV / DQG / FDFKH DUH SUHVHQW IRU HDFK FRUH ZKLOH WKH / FDFKH LV VKDUHG
L2 sedikit lebih jauh tetapi lebih besar kapasitasnya. Cache L3 diakses oleh semua core sebagai lapisan akhir
VVKRZQLQ)LJXUH/FDFKHSURYLGHVWKHODVWOD\HURIVWDWLFPHPRU\EHIRUH
5$0IRUVWRUDJH memori statik sebelum data dikirim ke RAM untuk penyimpanan.
WKHFDFKHKLHUDUFK\LVWKH,QWHO&RUHLSURFHVVRU7KH&RUHLKDVDQ/FDFKHRI
• Contoh hirarki cache adalah prosesor Intel Core i7 yang memiliki L1 cache
E IRU LQVWUXFWLRQV DQG NE IRU GDWD  7KH / FDFKH LVsebesar
NE SHU64kb
FRUH 7KH
per/core (32 kb untuk instruksi dan 32kb untuk data). L2 cache
PEWRPEVKDUHGDPRQJVWWKHFRUHVGHSHQGLQJRQKRZPXFK\RXZDQWWRSD\
sebesar 256kb per core. L3 cache mulai dari 4mb sampai 24mb dipakai
bersama antara core2.
• Programmer tidak dapat mengakses atau memanipulasi cache dengan
”mengacak2” keotomatisan kerjanya cache walaupun ada beberapa instruksi
cache. Cache diabstraksi dari programmer karena cache2 dikelola oleh
algoritma yang rumit untuk menjamin data yang diperlukan tersedia secepat
mungkin. Misalkan kode program merujuk suatu variable tertentu beberapa
kali, maka prosesor sepertinya (likely) menganggap potongan data itu penting,
maka data itu sepertinya (likely) di-prefetch dan ditaruh dalam cache untuk
quick retrieval oleh operasi2 berikutnya. Hal ini terjadi secara dinamis
sepanjang eksekusi program.
• Akan tetapi ada lokasi memori dalam prosesor yang mudah diakses yakni
)LJXUH&38FDFKH
Register2, sebuah lokasi memori tercepat dalam prosesor. Register2 ada pada
puncak hirarki memori, lebih kecil dan lebih cepat daripada cache. Register2
PPHUV GR QRW DFFHVV RU PDQLSXODWH FDFKH ZLWK FRGH adalah
LQ D QRQDXWRPDWLF
daerahZD\ penyimpanan kecil terdekat ke ALU yang dipakai untuk
QVWUXFWLRQV GR H[LVW &DFKH DFFHVVHV DUH DEVWUDFWHG IURP SURJUDPPHUV EHFDXVH
memegang operand2, alama2 dan hasil2 selama eksekusi instruksi2.
JHGE\FRPSOH[DOJRULWKPVWKDWHQVXUHWKHGDWDZHQHHGLVDYDLODEOHDVTXLFNO\DV
OH LI RXU FRGH UHIHUHQFHV D FHUWDLQ YDULDEOH PXOWLSOH WLPHV WKH SURFHVVRU ZLOO
HFHRIGDWDLVLPSRUWDQW7KHGDWDLVOLNHO\WREHSUHIHWFKHGDQGNHSWLQFDFKHIRU
XUHRSHUDWLRQV6XFKEHKDYLRUKDSSHQVG\QDPLFDOO\WKURXJKRXWWKHH[HFXWLRQRID

U\ ORFDWLRQV GR H[LVW RQ WKH SURFHVVRU WKDW ZH FDQ HDVLO\ DFFHVV LQ FRGH 7KH
Peningkatan Akses Memori
• Seperti sudah diketahui bahwa akses ke main memory (RAM) lebih lambat dibanding membaca
dari register2 karena proximity (jarak atau jauh dekat) ke ALU dan proses menghendaki membaca
nilai2 dari memori. Sepanjang waktu, banyak perbaikan2 untuk meningkatkan akses instruksi dan
data telah dibuat.
• Cache memory membantu memulihkan speed akses2 memori. Jika instruksi atau data sedang
dijemput belum sampai di cache, terjadi cache hit. Jika tidak ditemukan, terjadi cache miss.
Instruksi2 juga dapat dipindahkan dalam rencengan (bulk) ke dan dari cache.
• Algoritma2 Pre fetching menguji pola akses memori dengan maksud mengisi cache dan prefetch
buffers dengan instruksi2 dan data yang sepertinya (likely) segera diperlukan. Kebanyakan CPU
modern juga memiliki predecoding sebagai bagian dari pipeline.
• Integrated memory controllers menghilangkan CPU to RAM hops lewat front-side bus
(Northbridge) dengan mengintegrasikan memori ke dalam CPU die.
• Sistem multi-core/multi-processor menyebabkan beban kerja (workload) mengeksekusi instruksi2
jadi tersebar.
REGISTER 8086 • Karena register terletak di dalam
CPU, maka ia jauh lebih cepat
dibanding memori.1)
• Mengakses memori memerlukan
system bus sehingga menjadi
lebih lama.
• Register dipakai untuk
Flag Register mengontrol instruksi2 yang
sedang dieksekusi, menangani
pengalamatan memori, dan
menyediakan kemampuan
aritmetika.
General-Purpose Register Special-Function Register Segment Register
AX – the accumulator register (terbagi atas AH / AL) IP – Instruction Pointer
BX – the base address register (terbagi atas BH / BL) CS – code segment
CX – the count register (terbagi atas CH / CL)
DS – data segment
DX – the data register (terbagi atas DH DL)
SI – source index register SS – stack segment 1) Dalam ilmu Organisasi dan Arsitektur
ES – extra segment Komputer, dikatakan hampir tidak ada latensi
DI – destination index register antara CPU dan Register. Berbeda halnya
BP – base pointer dengan CPU dan memori.
SP – stack pointer
REGISTER 80386 (Untuk Referensi Saja)
REGISTER2 x86 DAN x86_64
64-bit 32-bit 16-bit 64-bit 32-bit 16-bit
RAX EAX AX CS CS
RBX EBX BX DS DS
RCX ECX CX ES ES
Segment Registers N/A
General RDX EDX DX SS SS
Purposer RSI ESI SI FS
Registers RDI EDI DI GS
RBP EBP BP Instruction Pointer RIP EIP IP
RSP ESP SP Flags Register RFLAGS EFLAGS FLAGS
R8 – R15

RFLAGS
 )LJXUH:ULWLQJ$;GHVWUR\V($;

,Q )LJXUH  \RX VHH WKDW ZKHQ D YDOXH ZDV FRSLHG WR D[ WKH ORZHU 
RYHUZULWWHQGHVWUR\LQJWKHRULJLQDOYDOXHLQHD[$JDLQWKHWZRUHJLVWHUVVKDUHP
Registers Overlapping (Tumpang Tindih) DOOUHJLVWHUVVKDUHVSDFHZLWKVXEUHJLVWHUVDQGHYHQWKHRQHVWKDWGRPD\VKDUHDG
VSDFH7KHIRXUJHQHUDOSXUSRVHELWUHJLVWHUVUD[UG[KDYHDVKDULQJUHODWLRQVKLS
ELWDQGELWFRXQWHUSDUWVDVVKRZQLQ7DEOH7DEOH OLVWV WKH UHPDLQLQJ
UHJLVWHUVUVLUGLUESDQGUVSZKLFKRQO\KDYHDVKDULQJUHODWLRQVKLSZLWKWKHLU
FRXQWHUSDUWV

7DEOH5HJLVWHURYHUODSSLQJIRU5$;5%;5&;DQG5';

)LJXUH5HJLVWHUDGGUHVVLQJ

7DEOH5HJLVWHURYHUODSSLQJIRU56,5',5%3DQG563

)LJXUH:ULWLQJ$;GHVWUR\V($;
$OWKRXJK
,Q )LJXUH  \RX VHH WKDW ZKHQ D YDOXH ZDV FRSLHG WR D[ WKH ORZHU  ELWV RI HD[ ZHUH \RX DUH DEOH WR XVH DOO RI WKH DIRUHPHQWLRQHG UHJLVWHUV LQ \RXU SURJU
RYHUZULWWHQGHVWUR\LQJWKHRULJLQDOYDOXHLQHD[$JDLQWKHWZRUHJLVWHUVVKDUHPHPRU\VSDFH1RW UHJLVWHUVKDYHVSHFLDOSXUSRVHVRIQRWH<RXFDQVWRUHGDWDLQDUHJLVWHUVXFKDVUD[
DOOUHJLVWHUVVKDUHVSDFHZLWKVXEUHJLVWHUVDQGHYHQWKHRQHVWKDWGRPD\VKDUHDGLIIHUHQWDPRXQWRI LWRYHUZULWWHQ SHUKDSVXQNQRZLQJO\ DIWHUWKHQH[WRSHUDWLRQ+HUHZHOLVWVRPHR
VSDFH7KHIRXUJHQHUDOSXUSRVHELWUHJLVWHUVUD[UG[KDYHDVKDULQJUHODWLRQVKLSZLWKWKHLUELW RIELWDQGELWUHJLVWHUVVR\RXFDQDYRLGHUURUVZKHQSURJUDPPLQJ
ELWDQGELWFRXQWHUSDUWVDVVKRZQLQ 7DEOH7DEOH OLVWV WKH UHPDLQLQJ JHQHUDO SXUSRVH ‡UD[HD[LVFRPPRQO\XVHGDVWKHGHIDXOWDFFXPXODWRUUHJLVWHU2SHUDWLRQVVXF
UHJLVWHUVUVLUGLUESDQGUVSZKLFKRQO\KDYHDVKDULQJUHODWLRQVKLSZLWKWKHLUELW DQGELW PXOWLSOLFDWLRQZLOODXWRPDWLFDOO\SODFHSDUWRIWKHUHVXOWLQUD[HD[)XQFWLRQ
FRXQWHUSDUWV IRUWKHUHWXUQYDOXH'RQRWXVHUD[HD[IRUGDWDVWRUDJHZKHQSHUIRUPLQJVXF
‡UF[HF[LVXVHGWRKROGWKHORRSFRXQWHUYDOXHIRUH[HFXWLQJORRSV6RDYRLG
7DEOH5HJLVWHURYHUODSSLQJIRU5$;5%;5&;DQG5'; KROGGDWDLQVLGHRIORRSV
Mikroprosesor 8086 memiliki beragam jenis register yang dapat dikelompokkan sesuai instruksi2 sebagai
berikut :
• General purpose registers: CPU 8086 memiliki 8 general purpose registers (GPR) 16-bit dan setiap
register memiliki nama seperti dalam Gambar yakni AX, BX, CX, DX, SI, DI, BP, SP. Empat word registers
(AX, BX, CX dan DX) dapat dipecah menjadi high dan low byte registers (AH, AL, BH, BL, CH, CL, DH dan
DL). Register BP, SI dan DI tergolong general purpose tetapi tidak dapat dipecah menjadi byte. SP juga
general purpose, tetapi lebih khusus sebagai stack pointer. Prosesor 386 dan selanjutnya masih
mendukung register2 general-purpose ditambah versi Extended 32-bit masing2: EAX, EBX, ECX, dan EDX.
• Special function registers: CPU 8086 memiliki 2 special function registers (SFR) yakni register IP dan
register flag (Terj. Ind. Bendera). Register IP (Instruction Pointer) dipakai untuk menunjuk instruksi yang
sedang eksekusi dan selalu bekerja bersama segment register CS (CS:IP). Fungsi utama register flag
adalah untuk memodifikasi operasi2 CPU setelah fungsi2 mekanik selesai dan menariknya kita tidak
dapat mengakses langsung register ini.
• Segment registers: CPU 8086 CPU memiliki 4 segment registers dengan panjang 16 bit yakni CS, DS, ES, SS
yang bertugas selain mungkin untuk menyimpan data, tetapi khususnya untuk rujukan atau referensi
mengakses blok memori atau segment atau paragraph boundary. Alamat segment selalu digeser ke
kanan sebanyak 4 bit bernilai 0 (atau dikali dengan desimal 16 atau heksa 10h).
Register CS. Berisi alamat awal segment kode program. Alamat segment ditambah nilai offset dalam Register IP
(instruction pointer) menunjukkan alamat instruksi yang akan dijemput (fetched) untuk dieksekusi. Untuk kondisi
pemrograman normal, Anda tidak perlu merujuk Register CS dalam program.
Register DS. Berisi alamat awal dari segment data program. Instruksi2 menggunakan alamat ini untuk menemukan data:
Alamat ini ditambah nilai offset dalam instruksi, menghasilkan referensi ke lokasi byte tertentu dalam segment data.
Register SS. Memampukan implementasi stack dalam memori dimana program menggunakan penyimpanan temporer
untuk alamat2 dan data. Sistem menyimpan alamat awal dari segment stack program dalam register ini. Alamat segment
ditambah nilai offset dalam Register SP (stack pointer) menunjukkan word terkini dalam stack yang akan dipakai. Dalam
pemrograman normal, Anda tidak perlu merujuk Register SS dalam program.
Register ES. Dipakai oleh beberapa operasi string (data karakter) untuk menangani pengalamatan memori. Dalam konteks
ini, Register ES (extra segment) diasosiasikan dengan Register DI (index). Program yang memerlukan Register ES perlu
menginisialisasikannya dengan alamat segment yang sesuai.
 Pengalamatan (Addressing) dengan segmentasi
• Intel 8086 16-bit dirancang kompatibel dengan mikroprosesor Intel 8080 8-bit. Mesin2 ini
memiliki ruang alamat 64 kilobytes diwakili oleh dua byte atau seluruh 16 bit. Artinya ruang
alamat yang bisa diakses adalah 216 atau 64 KiB.
• Akan tetapi Intel® memilih pendekatan yang berbeda yakni memanfaatkan segmentasi. Program2
akan jalan dalam satu segment. Setiap segment maksimal 64 kilobytes dan ada lebih dari satu
segment dalam memori. Dalam segment2 ini, maka program2 dimungkinkan memperlakukan
mesin seolah-olah hanya punya ruang alamat hanya 64 kilobytes. 1)
• Ini membuat transport program2 ke mesin2 8-bit jadi lebih mudah. Lebih jauh lagi, dua program
berbeda dapat memanfaatkan bersama ruang dalam memori.
• Intel memilih paragraph sebagai satuan dasar ruang segment. Dengan mengubah segment
pointer dari 0700H ke 0701H akan menaikkan segment sejauh 16 byte (satu paragraph) dalam
memori. Akibatnya alamat segment yang 16-bit digeser 4 bit ke kiri (atau dikalikan 16) menjadi
seolah-olah field 20-bit. Dengan demikian 8086 mampu mengalamatkan secara langsung 20 bit,
atau satu megabyte memori. Dari satu megabyte ini, 320 kilobyte teratas dipakai oleh Vendor
(misal IBM) untuk hal-hal seperti system ROM, cartridge ROM dan display memory. Itulah
sebabnya jumlah memori yang bisa dipakai untuk program hanya 640 kilobytes.
• Ada empat jenis segment dalam mesin. Yang pertama adalah code segment ditampung oleh CS.
Segment ini tempat dimana kode dieksekusi. Yang kedua adalah data segment, DS. Saat program
mencoba membaca dari memori sebagai data dan tidak ada segment tertentu yang ditunjuk,
prosesor akan melihat data segment. Yang ketiga adalah stack segment, SS. Operasi2 stack PUSH
dan POP dilakukan dalam segment ini. Yang terakhir adalah auxiliary segment, ES. Ini tergolong
sebagai general purpose segment register diserahkan pada programmer.
1) Jika program lebih dari 64 KiB, Anda dapat gunakan 32-bit protected mode yang ada pada mesin modern untuk mengatasi keterbatasan segment dalam DOS 16-
bit. Atau memanfaatkan fitur compiler large model. Anda cukup increment pointer2 dan dapat memakai array lebih besar dari 64 KiB; compiler yang atur.
Pointer Register (IP, SP dan BP)
• Register Instruction Pointer (IP). Register 16-bit berisi offset dari instruksi berikutnya yang akan
dieksekusi. IP terasosiasi dengan Register CS dimana IP menunjuk pada instruksi terkini dalam
code segment yang saat ini sedang eksekusi. Dalam kondisi normal, Anda tidak perlu merujuk ke
Register IP dalam program, tetapi Anda dapat mengubahnya menggunakan DEBUG.COM saat
menguji program. Prosesor 80386 dan selanjutnya memiliki Extended 32-bit IP yang dinamakan
EIP.
Alamat Segment dalam CS 39840h
Tambah alamat offset dalam IP + 514h
Alamat instruksi berikutnya 3A054h
Register SP (stack pointer) dan BP (base pointer) terasosiasi dengan Register SS dan mengijinkan
sistem mengakses data dalam stack segment.
• Register Stack Pointer (SP). Register 16-bit menyediakan nilai offset; saat terasosiasi dengan
Register SS, merujuk pada word terkini yang sedang diproses dalam stack. 80386 dan selanjutnya
memiliki Extended 32-bit stack pointer, Register ESP. Sistem menangani register2 ini secara
otomatis.
Alamat Segment dalam SS 4BB30h
Tambah offset dalam SP + 412h
Alamat dalam stack 4BF42h

• Register Base Pointer (BP). Register 16-bit memfasilitasi parameter2 perujukan (referensi)
dimana data dan alamat2 yang program lewati dalam stack. Prosesor menggabungkan alamat
dalam SS dan offset dalam BP. Prosesor 80386 dan selanjutnya memiliki Extended 32-bit BP ang
dinamakan Register EBP.
*(3 %3 '+%3 %3 *-((')+3 '#() *'%*3 %3 '+)3 "' 3 '()2
+ '%*3 +3 *3 -*-""13 *13 +'3 +)%*)3 + %*3 +/%3 +3 -#-"+')3
%3  +3 %03 ) *+)3 %3 . 3 .)*3
)
*3 3 /'"3 "**3 '3 /')! %3 ) *,)*3 ++3 %3 *).3  +)3
%+%3 ')3  +3 -**3 (% %3 '%3 '/3 +13 )3 '&&+3
*3 /')! %3 ) *+)*3 )3 ""3      3

'3 "'*3 )13 "'*3

+-""13 +3 '*3 )3 -*3 +'3 (' %+3 +'3 *'#/)3 "*3 3 )3
• Pointer Register dipakai untuk menunjukkan lokasi dimana data
%'+3 *'3 %+)*+3 %3 +3 '3 +*"3 *3 %3 /)3 +3 '3 *3 (' %+ %3
+
*3 +)13 diambil
+3 '%3 #')3 +dari
#3  atau
  3 disimpan ke.
 4000H

Secara default, register2

BX, SI, DI bekerja dengan
segment register DS. BP
dan SP bekerja dengan
segment register SS.

• Nilai dalam segment register (CS, DS, SS, ES) dinamakan ”segment”
• Nilai dalam General Purpose Register (BX, SI, DI, BP) dinamakan “offset”
• Saat DS berisi nilai 1234h dan SI berisi nilai 7890h maka dapat ditulis sebagai 1234:7890.
Alamat fisiknya menjadi 1234h * 10h + 7890h = 19BD0h
 Memahami Jenis
Pengalamatan Memori

Catatan: Untuk Referensi Saja

Prosesor 80286 ke atas menggunakan sejenis
tabel tambahan ( aka. Descriptor Table) untuk
pengalamatan sehingga mampu menangani
memori > 1024 Byte. [Protected Mode
Memory Addressing]
Pengalamatan (Addressing) dalam Gambar
Overlapping Segments
• Ketika menghitung physical address, sangat mungkin dua segment
tumpang tindih, yang juga seringkali memang diinginkan atau sengaja.
• Pada gambar di bawah ini, tumpang tindih digunakan pada file2 COM.
Register Index
Register SI dan DI tersedia untuk pengalamatan berindeks terutama
untuk digunakan dalam penjumlahan dan pengurangan.
• Register SI. Register Source Index 16-bit ini diperlukan untuk
beberapa operasi string (karakter). Dalam konteks ini, SI
terasosiasikan dengan Register DS. Prosesor 80386 dan selanjutnya
mendukung 32-bit extended register, ESI.
• Register DI. Register Destination Index 16-bit juga diperlukan untuk
beberapa operasi string. Dalam konteks ini, DI diasosiasikan dengan
Register ES. Prosesor 80386 dan selanjutnya mendukung 32-bit
extended register, EDI.
Register Flags
• Ada sembilan dari 16 bit Register Flags tersedia umum ke semua prosesor
keluarga 8086 untuk menunjukkan status terkini komputer dan hasil2
pemrosesan. Banyak instuksi2 yang melibatkan komparasi (perbandingan dan
logic aritmetika yang mengubah status flags, yangmana beberapa instruksi perlu
mengeceknya untuk menentukan aksi berikutnya.
• Flag-Flag yang tersedia umum (common flag bits) adalah :
• OF (overflow): sebagai indikasi overflow (tumpah) dari high-order bit (paling kiri) atas
aritmetika yang terjadi.
• DF (direction): menentukan arah kiri atau kanan untuk menggeser atau membandingkan data
string (karakter).
• IF (interrupt): sebagai indikasi seluruh interrupt eksternal, seperti entri keyboard, sudah siap
diproses atau diabaikan.
• TF (trap): mengijinkan operasi prosesor dalam mode single-step (satu langkah). Program2
debugger seperti DEBUG.COM mengeset trap flag sehingga Anda dapat selangkah
mengeksekusi satu instruksi tunggal pada stu waktu untuk menguji efeknya atas Register dan
Memori.
• SF (sign): berisi tanda hasil operasi aritmetika (0 = positif dan 1 = negatif)
• ZF (zero): sebagai indikasi hasil dari sebuah operasi aritmetika atau komparasi (0 = nonzero
dan 1 = hasil zero).
• AF (auxiliary carry): berisi carry out dari bit 3 atas data 8-bit, ini untuk aritmetika khusus saja.
• PF (parity): sebagai indikasi paritas genap atau ganjil atas operasi data 8-bit ordo rendah (low
order) atau paling kanan.
• CF (carry): berisi carry dari bit ordo atas (high-order) atau paling kiri akibat operasi aritmetika
sebelumnya; juga memuat isi dari bit terakhir atas operasi shift (geser) atau rotate (putar).
• Flag2 yang paling relevan dengan pemrograman Bahasa Assembly
adalah OF, SF, ZF dan CF untuk operasi2 komparasi dan aritmetika,
dan DF untuk arah operasi string.
• Prosesor 80286 dan selanjutnya memiliki 32-bit extended flags
register yang dikenal sebagai Eflags.
• Anda tak perlu mengingat lokasi2 berikut:
INPUT-OUTPUT INTERFACE
• BIOS berisi kumpulan routine2 dalam ROM untuk mendukung piranti. BIOS
mengetes dan inisialisasi piranti2 terpasang dan menyediakan layanan2 yang
diperlukan untuk membaca dari dan menulis ke piranti. Satu task dari DOS adalah
menjembatani dengan BIOS jika ada keperluan untuk mengakses fasilitas2 ini.
• Saat program user memerlukan layanan I/O dari OS, ia mengalihkan permintaan
ke BIOS, yangmana seterusnya mengakses piranti yang dikehendaki. Akan tetapi
kadang2 program membuat permintaan langsung ke BIOS, khususnya untuk
layanan2 keyboard dan layar. Lebih serius lagi, bisa juga program mengakses
piranti secara langsung.
User Program

DOS

BIOS

Hardware / Devices
• Intel 8086 merupakan mikroprosesor dengan data bus internal dan eksternal 16-bit, artinya
semua register lebarnya 16 bit dan ada data bus 16-bit yang mengirim data masuk dan keluar
CPU.
• Sekalipun pengenalan 8086 menandai lompatan yang besar atas generasi mikroprosesor
sebelumnya, masih ada hambatan terutama pada penggunaan data bus eksternal 16-bit karena
pada saat itu semua peripheral dirancang sekitar mikroprosesor 8-bit. Ditambah lagi printed
circuit board (PCB) dengan data bus 16-bit sangat2 mahal. Oleh sebab itu Intel mengeluarkan
versi 8088. Ia identik dengan 8086 sejauh berkenaan dengan pemrograman, tetapi secara
eksternal ia memiliki data bus 8-bit bukan bus 16-bit. Ia juga memiliki kapasitas memori 1
megabyte.
• Pada tahun 1981, keberuntungan Intel berubah selamanya ketika IBM memilih 8088 sebagai
mikroprosesor pilihan dalam merancang IBM PC. IBM PC berbasis 8088 sukses besar, terutama
saat IBM dan Microsoft (pengembang sistem operasi MS-DOS) membuatnya sebagai sistem
terbuka, artinya seluruh dokumentasi dan spesifikasi hardware dan software dari PC terbuka
untukk publik. Ini menyebabkan banyak vendor lain mudah meng-clone hardware dan dengan
demikian terjadi perkembangan dahsyat baik hardware maupun software yang dirancang
berdasarkan IBM PC. Ini sangat berbeda dengan komputer Apple yang menganut sistem
tertutup, yang mencegah setiap coba2 meng-clone oleh pabrikan lain baik domestik maupun
luarnegeri.
MODUL I/O
• Pada komputer modern, prosesor berkomunikasi dengan piranti2 eksternal, seperti keyboard, monitor dan
network adapter, lewat modul I/O yang tersambung ke system bus.
• Selain sebagai perangkat buffered communication antara prosesor dan piranti I/O, modul I/O juga
menangani beberapa critical actions seperti data transfer, command decoding dan device status
interrogation.
• Seperti halnya prosesor perlu CU yang bertindak sebagai pengatur lalulintas untuk memastikan instruksi2
dieksekusi tanpa teraduk dengan operasi lain, modul I/O juga harus mengkoordinasikan komunikasi antara
komponen2 internal komputer dengan piranti eksternal yang terhubung ke modul.
• Karena letaknya paling jauh dari CPU, maka piranti eksternal adalah piranti paling lambat dalam ekosistem
komputasi. Karena perbedaan speed, modul I/O perlu berlaku sebagai data buffer agar memastikan baik
prosesor tidak diperlambat atau piranti eksternal ”kerja dipaksa” (overrun) dengan terlalu banyak data.
• Piranti2 eksternal berbeda sering bekerja pada speed yang berbeda (mis. menyimpan data pada CDRW vs.
USB thumb drive), sehingga modul I/O perlu sadar akan data rate piranti terpasang dan menyesuaikannya.
• Tugas kritis modul I/O yang lain adalah melakukan error detection untuk memastikan data terkirim ke
piranti eksternal adalah data yang sama diterima oleh piranti eksternal. Beragam metode error detection
bisa dipakai (mis. checksums, Cyclic Redundancy Checks atau CRC, Hamming Code dan parity bits),
tujuannya selalu sama: memastikan integritas data.
 EXWLWFUHDWHVWKHPRVWRYHUKHDGWKXVPDNLQJLWWKHPRVWLQHIILFLHQWRIWKHFKRLFHV:KHQDSURFHVVRU
H[HFXWHVDQ,2RSHUDWLRQLQ3,2PRGHWKH&38VHQGVDFRPPDQGWRWKHVSHFLILHG,2PRGXOHDQG
ZDLWV7KH,2PRGXOHLVUHVSRQVLEOHIRUH[HFXWLQJWKHFRPPDQGDQGVHWWLQJWKHDSSURSULDWHELWVLQ
WKH ,2 VWDWXV UHJLVWHU WR VLJQLI\ WKH FRPSOHWLRQ RI WKH FRPPDQG 7KH SURFHVVRU PXVW SHULRGLFDOO\
FKHFNWKH,2VWDWXVUHJLVWHUWRVHHLIWKH,2PRGXOHKDVFRPSOHWHGWKHRSHUDWLRQ2YHUKHDGLVFDXVHG
E\WKHSHULRGLFFKHFNLQJHVSHFLDOO\LQWKHFDVHRIYHU\ORQJ,2RSHUDWLRQVZKHUHWKHSURFHVVRUPXVW
FKHFNPXOWLSOHWLPHV
OPERASI I/O 7KH SURFHVVRU FRXOG EH PXFK PRUH HIILFLHQW LI DIWHU VHQGLQJ D FRPPDQG WR DQ ,2 PRGXOH LW
FRXOG FRQWLQXH ZLWK RWKHU RSHUDWLRQV LQVWHDG RI ZDLWLQJ IRU WKH ,2 FRPPDQG WR ILQLVK 6XFK LV WKH
• Operasi2
FRQFHSWI/O yang dieksekusi
RI LQWHUUXSWGULYHQ oleh prosesor
,2 GHSLFWHG LQ )LJXUH umumnya ada
 2QFH WKH empatKDV
SURFHVVRU cara: programmed
GHOLYHUHG D I/O (PIO), interrupt-
driven I/O, direct memory access (DMA) dan I/O channels.
FRPPDQGWRDQ,2PRGXOHLWPRYHVRQWRRWKHULQVWUXFWLRQVDQGRQO\UHWXUQVWRWKHH[WHUQDORSHUDWLRQ
• ZKHQWKH,2PRGXOHVHQGVDQLQWHUUXSW7KHLQWHUUXSWSDXVHVRWKHURSHUDWLRQVVRWKDWWKHSURFHVVRU
Programmed I/O (PIO) merupakan teknik paling sederhana implementasinya, tetapi paling tinggi
FDQILQLVKWKH,2RSHUDWLRQDWKDQG7KHSURFHVVRUFKHFNVIRULQWHUUXSWVDWWKHHQGRIHYHU\LQVWUXFWLRQ
overheadnya karena ia paling tidak efisien mengambil pilihan2. Saat prosesor mengeksekusi sebuah operasi
F\FOHVRWKH,2PRGXOHZLOOQHYHUKDYHWRZDLWORQJHUWKDQRQHIXOOLQVWUXFWLRQF\FOHDIWHUGHOLYHULQJ
I/O dalam mode PIO, CPU mengirim perintah dan mengeset bit2 yang sesuai pada I/O status register untuk
DQ LQWHUUXSW PHVVDJH IRU WKH WUDQVDFWLRQ WR FRPSOHWH $OWKRXJK LW VHHPV OLNH WKH SURFHVVRU LV
menandai selesainya perintah. Prosesor harus secara periodik mengecek I/O status register untuk melihat
FRPSOHWHO\KDQGVRIIGXULQJWKH,2PRGXOH¶VH[HFXWLRQRIDFRPPDQGWKHSURFHVVRUVWLOOKDVWREH
apabila modul I/O telah menyelesaikan operasi.
XVHGHDFKWLPHGDWDLVPRYHGWRIURPPDLQPHPRU\ 5$0  Overhead disebabkan oleh pengecekan secara periodik,
terutama pada saat operasi2 I/O sangat panjang dimana prosesor harus mengecek beberapa kali.

)LJXUH3URJUDPPHG,2
• Prosesor bisa
%RWK lebih efisien
3URJUDPPHG jika
,2 DQG setelah mengirim
LQWHUUXSWGULYHQ ,2 UHTXLUHperintah ke modul
FRQVWDQW LQYROYHPHQW RI I/O, ia lanjut dengan operasi lain bukan
WKH SURFHVVRU
menunggu perintah I/O selesai. Konsep demikian dinamakan interrupt-driven I/O. Saat prosesor mengirim
6LQFHPDQ\,2RSHUDWLRQVDUHVWUDLJKWIRUZDUGGDWDWUDQVIHUVEHWZHHQH[WHUQDOGHYLFHVDQG5$0WKH
satu SURFHVVRU
perintahLVke modul
ZDVWLQJ I/O,
FORFN ia bergerak
F\FOHV RQ PXQGDQHke instruksi
WDVNV lainnya
6XFK RYHUKHDG danD UHPHG\
QHHGV hanya WR kembali
IXUWKHU ke operasi eksternal ketika
modul I/O mengirim sebuah interrupt. Interrupt menyela
LQFUHDVHWKHHIILFLHQF\RIWKHSURFHVVRUDQGGLUHFWPHPRU\DFFHVV (pause) operasi2 lain sehingga prosesor dapat
'0$ GHSLFWHGLQ)LJXUHLV
menyelesaikan operasi
WKH DQVZHU 8VLQJ '0$I/O segera.
UHTXLUHV Prosesor
DQ DGGLWLRQDO mengecek
PRGXOH interrupt2
RQ WKH PRWKHUERDUG di akhir
VWULFWO\ setiap siklus instruksi, sehingga
IRU '0$
modulRSHUDWLRQV:KHQWKHSURFHVVRUQHHGVWRH[HFXWHDQ,2RSHUDWLRQWKH&38VHQGVWKHLQIRUPDWLRQWR
I/O tak akan pernah menunggu lebih lama dari satu siklus instruksi penuh setelah adanya interrupt
WKH'0$PRGXOHLQVWHDGRIGLUHFWO\WRWKHGHYLFH¶V,2P,QDVHQVHWKH'0$PRGXOHHPXODWHVWKH
message agar transaksi diselesaikan. Sekalipun kelihatannya prosesor menyerahkan sepenuhnya eksekusi
SURFHVVRUE\WDNLQJFRQWURORIWKH,2RSHUDWLRQE\SDXVLQJWKHSURFHVVRUIRURQHF\FOHDWDWLPHVR
perintah kepada modul I/O, prosesor masih harus diberdayakan setiap kali data dipindahkan ke/dari
WKH'0$PRGXOHFDQJDLQXQIHWWHUHGDFFHVVWRWKHV\VWHPEXV
memori utama (RAM). DSURFHVVFDOOHGF\FOHVWHDOLQJ :KHQ
WKH '0$ PRGXOH KDV FRPSOHWHG WKH ,2 RSHUDWLRQ LW VHQGV DQ LQWHUUXSW WR WKH SURFHVVRU WR VLJQLI\
FRPSOHWLRQ 7KH SURFHVVRU LV RQO\ UHVSRQVLEOH IRU QRQGDWD WUDQVIHU LQVWUXFWLRQV UHODWHG WR WKH ,2
RSHUDWLRQZKLFKVDYHVFORFNF\FOHVDQGPDNHVWKHFRPSXWHU¶VXVDJHRIWKHSURFHVVRUPRUHHIILFLHQW
 )LJXUH,QWHUUXSWGULYHQ,2

)LJXUH,QWHUUXSWGULYHQ,2 )LJXUH'LUHFWPHPRU\DFFHVV

$OWKRXJK'0$DSSHDUVWRVROYHWKHSUREOHPRIWKH&38GHDOLQJZLWK,2RSHUDWLRQVWKH'
• Baik Programmed I/O maupun interrupt-driven PRGXOHI/O LWVHOI memerlukan keterlibatan
LV QRW D FRPSOHWH SURFHVVRU LW PXVWterus-menerus
VWHDO F\FOHV IURP WKHprosesor.
&38 WR DFFRPSOLVK '
Apabila banyak operasi I/O berupa data transfer antara piranti2 eksternal dan RAM, prosesor akan
WDVNV7KXVWKH&38LVVWLOOGRLQJPRUHZRUNWKDQLVRSWLPDO$VROXWLRQWRWKHF\FOHVWHDOLQJSURE
membuang banyak clock cycle untuk tugas2 LV WR KDYH D PRGXOH
biasa. Overhead GHGLFDWHG WR ,2 RSHUDWLRQV
demikian WKDW LV LQ IDFW
memerlukan solusiD UHDO SURFHVVRU 6XFK D WHFKQL
bagaimana
HOLPLQDWHV
meningkatkan efisiensi prosesor; jawabannya adalah direct memory access (DMA). Menggunakan WKH QHHG IRU D PRGXOH WR VWHDO F\FOHV IURP WKH &38 7KH VROXWLRQ
DMA LV DQ ,2 FKDQ
'LIIHUHQW,2FKDQQHOVH[LVWVRPHKDQGOH,2ZLWKRQHGHYLFHDWDWLPHDQGRWKHUVFDQPXOWLSOH[
memerlukan modul tambahan pada motherboard semata-mata untuk operasi2 DMA. Ketika prosesor
KDQGOH,2ZLWKPXOWLSOHGHYLFHVDWDWLPH :KHQ,2FKDQQHOVDUHSUHVHQWWKH&38LVUHOLHYH
mengeksekusi operasi I/O, CPU mengirim informasi ke modul DMA, bukan langsung ke piranti I/O. Seolah-
HYHU\,2LQVWUXFWLRQH[FHSWWKHYHU\ILUVWLQVWUXFWLRQWKDWWHOOVWKH,2FKDQQHOWRSHUIRUPDWDVN$
olah modul DMA)LJXUH'LUHFWPHPRU\DFFHVV
meng-emulasi prosesor mengambil kendali
WKH ILUVW LQVWUXFWLRQ WKH atas operasi
,2 FKDQQHO WDNHVI/O
RYHUdengan
DQG FRQWUROVmenyela prosesor
WKH ,2 PRGXOH FRPSOHWLQJ WKH
RSHUDWLRQZLWKRXWXVLQJDQ\PRUH&38F\FOHV
selama satu cycle pada satu waktu sehingga modul DMA bisa memperoleh akses bebas ke system bus
$OWKRXJK'0$DSSHDUVWRVROYHWKHSUREOHPRIWKH&38GHDOLQJZLWK,2RSHUDWLRQVWKH'0$
(proses
PRGXOH LWVHOI LV QRWini dinamakan
D FRPSOHWH SURFHVVRUcycle VWHDO F\FOHVKetika
stealing).
LW PXVW IURP WKHmodul DMA telah
&38 WR DFFRPSOLVK '0$menyelesaikan operasi I/O, ia mengirim
interrupt ke prosesor untuk menandai sudah6XPPDU\
WDVNV7KXVWKH&38LVVWLOOGRLQJPRUHZRUNWKDQLVRSWLPDO$VROXWLRQWRWKHF\FOHVWHDOLQJSUREOHP
selesai.Prosesor hanya bertanggung jawab untuk instruksi2
LV WR KDYH
nonD PRGXOH
dataGHGLFDWHG
transferWRterkait
,2 RSHUDWLRQV
dengan WKDW LV LQ IDFW DI/O
operasi2 UHDO yangmana
SURFHVVRU 6XFK D WHFKQLTXH
menghemat clock cycle dan membuat penggunaan
HOLPLQDWHV WKH QHHG IRU D PRGXOH WR VWHDO F\FOHV IURP WKH &38 7KH1RZ WKDW
VROXWLRQ \RX
LV KDYH
DQ ,2 ILQLVKHG
FKDQQHO WKLV FKDSWHU \RX VKRXOG KDYH D EDVLF XQGHUVWDQGLQJ RI SURFHVVRU
prosesor komputer menjadi lebih efisien. V\VWHPDUFKLWHFWXUH:HKDYHFRYHUHGLPSRUWDQWDVSHFWVRIDUFKLWHFWXUHWKDWDUHQHFHVVDU\IRUOHDU
'LIIHUHQW,2FKDQQHOVH[LVWVRPHKDQGOH,2ZLWKRQHGHYLFHDWDWLPHDQGRWKHUVFDQPXOWLSOH[ LH
RI$VVHPEO\SURJUDPPLQJLQFOXGLQJWKH&38PHPRU\LQVWUXFWLRQH[HFXWLRQDQG,2$OWKRXJK
KDQGOH,2ZLWKPXOWLSOHGHYLFHVDWDWLPH :KHQ,2FKDQQHOVDUHSUHVHQWWKH&38LVUHOLHYHGRI
$VVHPEO\FRGHZDVGLVFXVVHGLQWKLVFKDSWHUDOORIWKHFRQFHSWVDUHFUXFLDOIRUZKDW\RXZLOOOH
HYHU\,2LQVWUXFWLRQH[FHSWWKHYHU\ILUVWLQVWUXFWLRQWKDWWHOOVWKH,2FKDQQHOWRSHUIRUPDWDVN$IWHU
WKH ILUVW LQVWUXFWLRQ WKH ,2 FKDQQHO WDNHV RYHU DQG FRQWUROV WKH ,2LQ VXEVHTXHQW
PRGXOH FKDSWHUV
FRPSOHWLQJ WKH<RX
,2ZLOO ILQG \RXUVHOI UHIHUULQJ WR WKLV FKDSWHU VSHFLILFDOO\ WKH VHFWLRQV
RSHUDWLRQZLWKRXWXVLQJDQ\PRUH&38F\FOHV PHPRU\DQG&38UHJLVWHUVDV\RXUHDGIXWXUHFKDSWHUVDQGZULWH\RXUILUVW$VVHPEO\SURJUDPV

6XPPDU\ .H\7HUPV
DGGUHVVEXV RI SURFHVVRU DQG
1RZ WKDW \RX KDYH ILQLVKHG WKLV FKDSWHU \RX VKRXOG KDYH D EDVLF XQGHUVWDQGLQJ
• Walaupun DMA hadir menyelesaikan masalah CPU berkenaan dengan operasi2 I/O, modul DMA itu sendiri
bukanlah prosesor yang lengkap; ia harus “mencuri” cycle dari CPU untuk menyelesaikan tugas2 DMA.
Dengan demikian CPU masih melakukan kerja. Solusi untuk masalah cycle-stealing ini adalah memiliki satu
modul yang terdedikasi untuk operasi2 I/O yakni, sudah tentu, prosesor yang nyata. Teknik demikian
menghilangkan kebutuhan akan modul untuk mencuri cycle dari CPU. Solusi ini dinamakan I/O channel.
• Kanal2 I/O berbeda; beberapa menangani I/O dengan satu piranti pada satu waktu, yang lain bisa multiplex
(yakni menangani I/O dengan beberapa piranti pada satu waktu). Ketika ada beberapa I/O channel, CPU
terbebas dari setiap instruksi I/O kecuali instruksi yang pertama yang memberitahukan I/O channel untuk
melakukan sebuah tugas. Setelah instruksi pertama, I/O channel mengambil alih dan mengendalikan modul
I/O, menyelesaikan operasi I/O tanpa menggunakan CPU cycle lagi.
Sisi Perangkat Lunak
(Sistem Operasi, Proses Boot, Stack, Pengalamatan
Instruksi dan Data)
Sistem Operasi
• Sistem Operasi menyediakan akses umum (general), bebas-piranti (device-
independent) ke sumberdaya2 komputer seperti keyboard, layar dan disk
drive.
• “Device Independence” berarti Anda tidak perlu urus piranti habis2an
karena sistem akan menangani operasi2 I/O pada tingkat piranti, tidak
perlu bergantung pada program yang meminta operasi itu.
• Organisasi Sistem Operasi MS-DOS
Ada tiga komponen utama: IO.SYS, MSDOS.SYS dan COMMAND.COM
IO.SYS melakukan fungsi2 inisialisasi saat bootup dan juga berisi fungsi2 I/O penting
dan device drivers yang melengkapi (suplement) dukungan primitive I/O dalam ROM
BIOS. Komponen ini disimpan dalam disk sebagai system file tersembunyi dan dikenal
pada PC-DOS sebagai IBMBIO.COM.
MSDOS.SYS berlaku sebagai kernel sistem dan terkait dengan manajemen file,
manajemen memori dan I/O. Komponen ini disimpan dalam disk sebagai system file
tersembunyi dan dikenal pada PC-DOS sebagai IBMDOSCOM.
COMMAND.COM merupakan prosesor perintah atau shell yang bertindak sebagai
antarmuka antara user dan sistem operasi. Ia menampilkan user prompt, memonitor
keyboard dan memproses perintah2 user seperti menghapus sebuah file atau
mengangkat (loading) sebuah program untuk dieksekusi.
Proses Boot
• Ketika komputer pertama dihidupkan terjadilah “cold boot”. Prosesor masuk ke reset
state membersihkan semua lokasi memori menjadi zero atau NOL, melakukan parity
check dari memori, dan mengeset register CS ke alamat segment FFFFh dan register IP ke
offset zero. Oleh karena itu instruksi pertama yang siap dieksekusi akan berada di alamat
pasangan CS:IP yakni FFFF0h, sebuah titik entri ke BIOS dalam ROM.
• BIOS Routine yang mulai pada lokasi FFFF0h mengecek beragam port untuk identifikasi
dan inisialisasi piranti2 yang terhubung ke komputer lalu membangun dua data area:
1. Sebuah interrupt vector table, mulai dari memori rendah pada lokasi 0 dan berisi alamat2 untuk
interrupt bekerja.
2. Sebuah BIOS data area mulai lokasi 40(0)h, kebanyakan berkenaan dengan piranti2 terpasang.
• Lalu BIOS menentukan apakah disk yang berisi system files ada, dan jika ada ia
mengakses bootstrap loader dari disk. Program ini mengangkat (load) system files IO.SYS
dan MSDOS.SYS dari disk ke memori dan memindahkan kendali ke titik entri dari IO.SYS,
yamgmana berisi device drivers dan kode hardware-specific lainnya. IO.SYS merelokasi
dirinya sendiri dalam memori dan selanjutkan memindahkan kendali kepada MSDOS.SYS.
Modul ini menginisialisasi tabel2 internal DOS dan porsi DOS dalam tabel interrupt. Ia
juga membaca file CONFIG.SYS dan mengeksekusi perintah2. Akhirnya MSDOS.SYS
menyerahkan kendali kepada COMMAND.COM yang memproses file AUTOEXEC.BAT,
menampilkan prompt dan memonitor input dari keyboard.
• Pada titik ini, memori konvensional sebesar 640K sudah muncul seperti Gambar 2-1. Di
bawah manajemen memori, bagian dari sistem direlokasi ke memori atas.
 Struktur Memori Setelah
Sistem Operasi Loading
Agar supaya program dapat dijalankan pada PC, DOS perlu
mengangkat (load) dulu ke dalam RAM. Dimanakah letaknya pada
RAM ? Pada saat merancang IBM PC yang berbasis 8088 dengan
kemampuan memori 1 megabyte (alamat 20-bit 00000 sd. FFFFFh)
membuat alokasi memori yang disebut memory map.
1. Alamat 00000-9FFFFh (640K byte) diperuntukkan untuk RAM
2. Alamat A0000h-BFFFFh (128K byte) dialokasikan untuk memori
video
3. Sisanya alamat C0000h-FFFFFh (256K byte) diperuntukkan untuk
ROM.
Mengenai RAM
Pada awal 1980-an kebanyakan PC hanya punya RAM 64K sampai 256K byte yang dianggap cukup
pada saat itu. User perlu membeli tambahan memory expansion board untuk mencapai 640K jika
memang diperlukan, biasanya tergantung dari versi DOS yang dipakai dan kebutuhan software
aplikasi. DOS mengalokasikan RAM yang tersedia untuk keperluan PC sendiri dan sisanya untuk
aplikasi misal word processor. Tugas mengelola memori RAM diserahkan kepada DOS mengingat
setiap versi DOS berbeda pemakaian memorinya dan komputer berbeda bisa memiliki jumlah RAM
berbeda, apalagi paket aplikasi juga berbeda2 kebutuhannya. Alasan itulah mengapa kita tidak
menetapkan (assign) nilai2 register CS, DS dan SS karena penetapan demikian berarti memastikan
alamat fisik dalam rentang 00000 – 9FFFFh dan ini di luar pengetahuan user. Alasan lainnya adalah
penetapan demikian bisa saja bekerja di satu PC, tetapi tidak di PC lain dengan versi DOS dan ukuran
RAM berbeda. Oleh karena itu manajemen memori adalah salah satu fungsi maha penting sistem
operasi DOS dan seharusnya memang diserahkan kepada DOS.
Ini penting diingat karena banyak contoh dalam Modul ini yang menyangkut nilai2 register CS, DS
dan SS akan Anda temukan berbeda pada PC Anda.

Video RAM
Dari alamat A0000h sampai dengan BFFFFh diperuntukkan video. Jumlah yang dipakai dan lokasinya
beragam tergantung dari video board terpasang pada PC.
Lebih Jauh tentang ROM
Dari C0000h sampai FFFFFh diperuntukkan ROM. Tidak semuanya digunakan oleh PC ROM. Dari
256K byte, hanya 64K byte dari lokasi F0000h – FFFFFh dipakai oleh BIOS (basic input/output) ROM.
Sebagian ruang sisanya digunakan oleh beragam adapter card (mis. card2 untuk hard disk), sisanya
bebas. DOS terakhir2 memiliki kemampuan manajemen memori bagus dan mampu menggunakan
ruang memori lebih dari 640K. Ruang memori dari 00000 sampai 9FFFFh dinamakan conventional
memory, kemudian sejumlah 384K byte dari A0000h sampai FFFFh dinamakan UMB (upper memory
block) seperti tertulis dalam dokumentasi DOS 5.

Fungsi BIOS ROM

Karena CPU hanya mengeksekusi program2 yang telah tersimpan dalam memori, maka harus ada
sebagian memori permanen (volatile) untuk memegang program2 yang memberitahu CPU apa yang
perlu dilakukan ketika komputer pertama menyala (power on). Kumpulan program ini dipegang oleh
ROM yang sering disebut BIOS dalam literatur2 komputer. BIOS, singkatan dari basic input-output
system, berisi program2 untuk mengetes RAM dan komponen lain yang terhubung ke CPU. Ia juga
berisi program2 agar DOS dapat berkomunikasi dengan piranti2 peripheral seperti keyboard, video,
printer dan disk. Adalah fungsi BIOS mengetes jika ada error. Contoh, jika keyboard terlepas dari PC
sebelum komputer nyala, BIOS akan melaporkan error pada layar, mengindikasikan kondisi itu.
Adalah hanya setelah pengetesan dan pengesetan (set up) peripheral2 oleh BIOS maka DOS
diangkat (load) ke dalam RAM dan menyerahterimakan (hand over) kendali PC ke DOS. Walaupun
ada kalanya ketika DOS maupun program aplikasi perlu menggunakan program2 dalam BIOS ROM,
DOS selalu mengendalikan PC setelah ia diangkat (loaded).
INTERRUPT
• INT <Destination_Operand> adalah instruksi bahasa assembly pada prosesor x86 yang membangkitkan
interupsi atau exception handler software yang memanggil (CALL) fungsi yang sesuai dengan operandnya.
Interrupt itu sendiri bukan hanya berupa instruksi bahasa assembly, tetapi juga hardware. Interrupt adalah
cara bagaimana mendapat perhatian dari prosesor.1)
• Destination Operand memerinci bilangan vektor interrupt dari 0 sampai 255 (INT 00 sampai INT 0FFh), yang
disandikan sebagai 8-bit unsigned immediate value.
• 0 – 4 terdedikasi
• 5 – 31 direservasi buat penggunaan sistem
• 08h – 0Fh : 8259A
• 10h – 1Fh : BIOS
• 32– 255 direservasi untuk user
• 20h – 3Fh : DOS
• 40h – FFh : terbuka (open)

• Interrupt vector menunjuk alamat masuk

(entrance address) dari interrupt service
routine (ISR) yang sesuai. Interrupt Vector
Table (IVT) diletakkan pada 1KiB (1024)
pertama dalam memori RAM.

1) Cara lain mendapat perhatian dari prosesor adalah polling.

Jenis-jenis Interrupt:
1. Internal HW Interrupts
• dibangkitkan oleh peristiwa atau event tertentu yang terjadi Interrupt Vector Table (IVT)
pada waktu / selama eksekusi program.
• diatur oleh HW dan tidak mungkin diubah
• contoh: interrupt untuk counter clock internal; HW call
interrupt ini untuk menjaga “time to date”.
2. External HW Interrupts
• dibangkitkan oleh piranti peripheral yakni keyboard, printer
dsb.
• biasa juga dibangkitkan oleh Co-Processor
• tidak mungkin di-non-aktifkan (deactivate)
• tidak dikirim langsung ke CPU, melainkan ke IC yang
memiliki fungsi untuk menangani secara eksklusif interrupts
ini (IC PIC8259A yang dikendalikan oleh CPU dengan
menggunakan urutan komunikasi atau path control)
3. Software Interrupts
• diaktifkan langsung oleh Assembler melalui sejumlah
interrupt dengan instruksi INT.
• ada dua jenis: interrupt DOS dan interrupt BIOS.
 Langkah-langkah yang terlibat dalam pemrosesan
instruksi interrupt oleh prosesor:
1. Eksekusi instruksi interrupt
2. JMP ke Interrupt Vector Table
3. Ambil CS dan IP dari IVT
4. PUSH CS dan IP yang ada ke dalam stack
5. LOAD CS dan IP yang baru
6. JMP ke Interrupt Service Routine
7. Eksekusi Interrupt Service Routine
8. Kembali dan lanjutkan Main Program

Interrupt BIOS lebih cepat dibanding interrupt DOS tetapi implementasinya sangat bergantung pada
hardware (hardware specific). Penggunaan interupt DOS biasanya mudah. Pemilihan interrupt tergantung
pada karakteristik yang akan kita berikan pada program: SPEED à BIOS, PORTABILITY à DOS.
Interrupt yang sering digunakan:
• INT 21h (DOS) adalah interrupt DOS yang paling banyak digunakan untuk banyak fungsi
• INT 10h (BIOS) Video I/O
• INT 16h (BIOS) Keyboard I/O
• INT 17h (BIOS) Printer I/O
 Interrupts

Hardware Software
Interrupts Interrupts INT n

256 jenis Software

Nonmaskable Maskable
Interrupts INT 00 sampai
Interrupts Interrupts INT 0FFh

Programmer tidak dapat

mengendalikan saat non-
Programmer dapat maskable interrupt dilayani
memilih untuk mask
interrupt2 tertentu Prosesor harus menghentikan
dan re-enable nanti main program agar mengeksekusi
NMI Service Routine.

Vijay Kumar K., Dept. of ECE INTUACEK, “Interrupts on 8086 Microprocessor”,

https://www.slideshare.net/VijayKumar486/interrupts-on-8086-microprocessor-by-vijay-kumark,
accessed on Oct 21, 2019.
RESET sebagai Non-maskable Interrupts

Urutan proses dalam prosesor :

1. selesaikan instruksi terkini yang sedang dikerjakan
2. PUSH nilai2 Flag Register ke dalam stack
3. PUSH nilai CS dan IP untuk alamat return ke dalam stack
4. LOAD IP dari isi word di lokasi 00008h
5. LOAD CS dari isi word di lokasi 0000Ah
6. Interrupt Flag dan Trap Flag di-reset ke 0
Non-Maskable
Software Interrupts Hardware Interrupts
Interrupts
digunakan digunakan untuk menangani perangkat keras
digunakan oleh Sistem Operasi
saat power peripheral yakni keyboard, mouse, hard disk, floppy
sebagai "pengait" ke beragam fungsi2
failure disk, DVD drive dan printer
digunakan saat digunakan sebagai mekanisme
critical response komunikasi antar bagian Tanpa interrupt, sistem akan sangat sederhana.
times berbeda dari sebuah program
Semua arsitektur mikroprosesor memiliki
digunakan saat non- kemampuan layanan interrupt bawaan (in-built
recoverable hardware
errors interrupt service)

digunakan sebagai Watchdog

Interrupt

digunakan saat Memory Parity

errors
Polling vs Interrupt (Untuk Referensi Saja)
• Untuk mendapatkan perhatian dari prosesor dapat digunakan polling atau interrupt.
• Untuk memahami perbedaan keduanya, dipakai contoh pengendalian robot menggunakan Polling
dan Interrupt.
• Polling :
• Bergerak maju dalam satuan yang sudah didefinisikan (predefined)
• Cek pembacaan sensor
• Jika tidak ada gangguan jalan terus atau belok jika ada halangan
• Ulang kembali dan bergerak maju lagi.

• Interrupt :
• Terus bergerak sampai diinterupsi oleh sensor
• Interrupt diterima lalu lakukan operasi yang telah didefinisikan
• Setelah menyelesaikan layanan interrupt, kembali ke operasi
normal, yakni kembali bergerak lagi.
Bagaimana Memperoleh Ketikan dari Keyboard ?
• Polling
CPU mengeksekusi sebuah program yang mengecek data tersedia. Jika tombol tuts ditekan
maka baca data, selain itu terus tunggu (waiting) atau ulang (looping).
• Interrupt
CPU mengeksekusi program lain, begitu ada tombol tuts ditekan, Keyboard membangkitkan
sebuah interrupt. CPU akan merespons ke interrupt membaca data. Setelah itu kembali ke
program sebelumnya. Sehingga dengan penggunaan interrupt yang tepat, CPU mampu
melayani banyak piranti2 pada waktu yang sama sekaligus.
• Keyboard controller hanya mampu menyimpan satu keystroke tunggal. Oleh
karena itu, keyboard controller harus “dibebaskan” sebelum keystroke berikutnya
tiba.
• Keystroke dikirim ke CPU dengan meletakkannya dalam keyboard buffer sehingga
keyboard controller dapat terus menjaga keyboard input ke CPU.
Sistem Berbasis Polling
Keystroke dikirim ke CPU

Tak ada Keystroke dikirim ke CPU

Sistem Berbasis Interrupt

Sistem Berbasis Polling

tak ada keystroke

setelah 20ms, wait
atau loop

ada keystroke

Sistem Berbasis Interrupt

Apakah STACK dan Mengapa Diperlukan ?
• Stack adalah bagian dari read/write memory (RAM) yang digunakan CPU untuk
menyimpan informasi temporer. CPU perlu area penyimpanan ini karena
terbatasnya jumlah register. Oleh karena itu harus ada suatu tempat agar CPU
dapat menyimpan informasi dengan aman dan temporer.
• Pertanyaannya adalah mengapa tidak merancang CPU dengan banyak register.
Alasan tentang desain CPU adalah setiap transistor itu ad harganya dan tidak akan
cukup untuk membangun ratusan register. Lagi pula seberapa banyak register
yang CPU bisa puaskan setiap program atau aplikasi? Semua aplikasi dan teknik
pemrograman tidak ada yang sama.
• Kekurangan utama dari stack adalah waktu aksesnya (access time). Karena stack
berada dalam RAM, butuh waktu lebih lama mengakses dibanding register. Apa
lagi register berada dalam CPU, RAM di luar. Inilah alasan beberapa komputer
super (tentunya mahal) tidak punya stack; CPU memiliki sejumlah register yang
banyak untuk kerja.
Stack
• Baik program .COM maupun .EXE memerlukan sebuah area dalam program
yang dicadangkan sebagai stack. Gunanya adalah sebagai ruang untuk
penyimpanan temporer dari alamat2 dan data.
• Program loader secara otomatis mendefinisikan stack untuk program
.COM, tetapi Anda harus secara eksplisit mendefinisikannya untuk program
.EXE.
• Setiap data item dalam stack berukuran 1 word (2 byte).
• Register SS, yang di-inisialisasi oleh loader, beris alamat dari awal stack.
Awalnya register SP berisi ukuran dari stack, nilai yang menunjukkan byte
di penghujung akhir stack. Stack berbeda dari segment lain dalam hal cara
menyimpan data. Ia mulai menyimpan data pada lokasi teratas dalam
segment dan menyimpan data turun ke bawah sepanjang memori.
• Instruksi PUSH dan POP dipakai untuk menyimpan data dalam stack dan
mengambilnya kembali. Ini mirip seperti tumpukan nampan di restoran.
Ketika PUSH dieksekusi, nilai SP berkurang 2 ke storage word lebih rendah
berikutnya dalam stack dan menyimpan (atau mendorong, pushing)
nilainya di situ. Sebaliknya POP mengambil nilai dari stack dan menaikkan
SP sebanyak 2 merujuk ke storage word yang lebih atas berikutnya.
ILUSTRASI PUSH DAN POP REGISTER AX DAN BX
Anggaplah AX berisi heksa 026Bh, BX berisi 04E3h dan SP berisi 36h. Alamat segment dalam SS tidak
diperhatikan.
Awalnya, stack masih kosong, dan terlihat seperti ini:

PUSH AX SP berkurang 2 (menjadi 34h) dan isi AX (026Bh) ke dalam stack.

Perhatikan operasi membalik urutan byte tersimpan sehingga 026Bh menjadi 6B02h:

SP berkurang 2 (menjadi 32h) dan simpan BX (04E3h) ke dalam stack sebagai E304h:
PUSH BX

Mengambil word dari lokasi yang ditunjuk SP dalam stack (E304h) masuk ke dalam register BX dan tambahkan SP
POP BX dengan 2 (menjadi 34h). Sekarang BX berisi 04E3h, dengan urutan byte2 terkoreksi. Sekarang stack menjadi :

Mengambil word dari lokasi yang ditunjuk SP dalam stack (6B02h) masuk ke dalam register AX dan tambahkan SP
POP AX dengan 2 (menjadi 36h). Sekarang AX berisi 026Bh dengan urutan byte2 terkoreksi.
POP AX Mengambil word dari lokasi yang ditunjuk SP dalam stack (6B02h) masuk ke dalam register AX dan tambahkan SP
dengan 2 (menjadi 36h). Sekarang AX berisi 026Bh dengan urutan byte2 terkoreksi. Sekarang stack terlihat
seperti :

• Perhatikan bahwa instruksi2 POP ditaruh dalam urutan terbalik dari instruksi2 PUSH; pada contoh
di atas PUSH register2 AX dan BX, tetapi POP BX dan AX (urutannya dibalik, seperti menaruh dan
mengambil nampan dari tumpukan)
• Perhatikan pula bahwa nilai2 yang telah ditaruh ke dalam stack masih terus ada, walaupun SP
sudah tidak lagi menunjuknya.
• Anda harus selalu memastikan program Anda konsisten memelihara urutan PUSH dan POP.
Walaupun terlihat sederhana, ini sering menyebabkan program crash.
• Bagi program .EXE, Anda perlu mendefinisikan ruang stack yang cukup besar untuk memegang
semua nilai yang akan di PUSH..
• Instruksi2 terkait dengan mendorong (push) nilai ke dalam stack dan mengambil (pop) kembali
adalah:
• PUSHF dan POPF: save dan restore status dari flags
• PUSHA dan POPA (untuk 80286 ke atas): save dan restore isi semua GPR.
Pengalamatan Instruksi dan Data
• Sebagai programmer Bahasa Assembly menulis program dalam kode
simbolik dan menggunakan Assembler untuk menerjemahkannya ke
kode mesin.
• Agar program bisa jalan, sistem mengangkat (load) hanya kode mesin
ke memori. Setiap instruksi berisi sedikitnya satu operasi, yakni move,
add, atau return. Bergantung operasinya, sebuah instruksi juga bisa
punya satu atau lebih operand yang merujuk data operasi untuk
diproses.
• Program .EXE menggunakan register CS untuk menyediakan alamat
awal code segment program, dan register DS menyediakan alamat
awal dari data segment. Code Segment berisi instruksi2 yang akan
dieksekusi, sedangkan Data Segment berisi data dimana instruksi2
merujuk. Register IP sebagai alamat offset dari instruksi terkini dalam
code segment yang akan dieksekusi. Operand instruksi menunjukkan
alamat offset dalam data segment yang dirujuk.
 • Bayangkan sebuah contoh dimana program loader telah ditentukan untuk mengangkat (load)
program .EXE ke memori, mulai lokasi 05BE0h. Maka loader mengeset register CS dengan
alamat segment 05BEh. Program yang sudah siap dieksekusi, dan IP terkini berisi offset 0023h.
CS:IP bersama2 menentukan alamat dari instruksi berikutnya yang akan dieksekusi sebagai
berikut:
Alamat segment CS: 05BE0h
IP offset: +0023h
Alamat Instruksi: 5C03h
• Anggaplah instruksi mulai 05C03h menyalin isi dari sebuah byte dalam memori ke dalam
Lokasi register AL; byte tersebut ada di offset 0016h dalam data segment. Maka kode mesin dan kode
05C03h
simbolik operasi ini: Catatan:
A01600 MOV AL,[0016] A0 adalah kode mesin dari instruksi MOV
• Alamat memori 05C03h berisi byte pertama (A0) dari instruksi yang prosesor akan akses. Byte
kedua dan ketiga berisi nilai offset dalam urutan byte terbalik (0016 menjadi 1600).
• Katakanlah loader telah menginisialisasi register DS dengan alamat segment 05D1h. Untuk
mengakses data item, prosesor menentukan lokasinya dari alamat segment di register DS
tambah offset (0016h) dalam operand instruksi. Karena DS berisi 05D1h, lokasi aktual data
item yang dirujuk adalah:
Alamat segment DS: 05D10h
Segment offset: +0016h
Alamat data item: 5D26h
• Katakanlah pada alamat 05D26h berisi 4Ah. Prosesor lalu mengekstrak 4Ah pada alamat 05D26h,
menyalinnya ke register AL seperti Gambar 2-3.

• Saat prosesor menjemput setiap byte instruksi, ia menaikkan/tambah register IP dengan 1. Karena
asalnya IP adalah 23h dan kode mesin yang sedang eksekusi sebesar 3 byte, sekarang IP berisi
0026h, yakni offset untuk instruksi berikutnya. Prosesor sekarang siap untuk instruksi berikutnya,
yang lokasinya efektif dari alamat segment dalam CS (05BEh) tambah offset dalam IP (0026h) yakni
05C06h.
• Instruksi bisa mengakses lebih dari satu byte pada satu waktu. Misalkan, anggaplah sebuah
instruksi untuk menyimpan isi dari register AX (0248h) menjadi dua byte berturutan dalam data
segment mulai offset 0016h. Kode simbolik MOV [0016],AX. Operand [0016] dalam kurung kotak
(operator indeks) menunjukkan lokasi memori, untuk membedakannya dari nilai 16. Prosesor
menaruh dua byte ke dalam AX dalam urutan yang terbalik sebagai:
Isi Byte 48 02
Offset dalam Data Segment 0016 0017
• Instruksi lainnya MOV AX,[0016] mengambil byte2 ini dengan menyalinnya dari memori kembali ke
AX. Operasi membalik (dan mengkoreksi) byte2 dalam AX sebagai 02 48.
OPERAND2 INSTRUKSI
• Salah satu fitur dari operand2 instruksi yang perlu diperjelas adalah penggunaan
nama2, berupa nama2 dalam kurung kotak dan bilangan2. Dalam contoh berikut,
DW mendefinisikan WORDX sebagai sebuah word (2 byte):
WORDS DW 0 ;Define WORDX as word
…
MOV CX,WORDX ;Move contents of WORDX to CX
MOV CX,25 ;Move value 25 to CX
MOV CX,DX ;Move contents of DX to CX
MOV CX,[DX] ;Move contents of location addressed by DX

• MOV pertama memindahkan data antara memori dan register.

• MOV kedua memindahkan immediate data ke register.
• MOV ketiga memindahkan data antar register.
• Kurung kotak pada MOV keempat mendefinisikan index operator yang artinya:
Gunakan alamat offset dalam DX (digabungkan dengan alamat segment dalam
DS, DS:DX) untuk menemukan sebuah word dalam memori dan memindahkan
isinta ke CX. Bandingkan efek instruksi ini dengan MOV ketiga yang hanya
memindahkan isi DX ke CX.
• Akses ke register pada 8086 tidak seluruhnya bebas. Misalkan kita
dapat isikan immediate values seperti angka ke GPR mana saja, tetapi
tidak ke segment register.
• Kita dapat taruh angka 6 ke BX dalam satu instruksi:
!"# $%, 6
• Menaruh 6 ke DS memerlukan
dua instruksi karena segment
register hanya bisa diubah
lewat GPR, bukan konstanta
atau segment register lain. 1)
MOV BX, 6
MOV DS, BX

1) ini dinamakan mode pengalamatan register indirect.

……. lihat Addressing Mode dalam 8086
ADDRESSING MODE DALAM 8086
Mode2 pengalamatan adalah kunci atas operasi2 canggih dalam komputer. 8086 menyediakan
beberapa: immediate, memory indirect dan register indirect.
• Immediate. Nilai2 langsung ditulis, seperti bilangan2.
Contoh: MOV BX,6
• Memory Indirect. Nilai2 yang berada pada suatu lokasi dalam data segment. Misal:
MOV BX, FOO
.
.
FOO DW 6
Ini akan “memindahkan” (sebenarnya menyalin) nilai 6 yaitu apapun isi variabel FOO, ke dalam
BX.
• Register Indirect. Ada dua jenis register untuk operasi ini: Base Register (BX dan BP) dan Index
Register. (SI dan DI). Pada mode ini, register berisi alamat dalam data segment dimana
informasi yang dikehendaki tersimpan. Misal:
MOV AX, 0F000h
MOV ES, AX
MOV SI, 0FFFEh
MOV DL, BYTE PTR ES:[SI]
Kode di atas akan membaca machine ID pada lokasi F000:FFFE menggunakan indirect mode
lewat register SI. Sebuah register indirect reference bisa memiliki sedikitnya satu Register Index
dan satu Register Base. Ini menjadi cara mudah mengindeks dalam array / larik, atau struktur
data.
Mode2 pengalamatan dapat dikombinasi sesuka Anda.
Bahasa Assembly
 Program Bahasa Assembly 8086
Pemrogaman Bahasa Assembly 8086 punya beberapa aturan seperti :
• Kode harus ditulis dalam huruf besar
• Label2 harus diikuti dengan titik dua, misalkan:
!"#$!:
• Seluruh label dan simbol harus mulai dengan huruf
• Seluruh komentar diketik dalam huruf kecil
• Baris terakhir program harus diakhiri dengan END directive

Untuk kemudahan pemahaman maka pelajaran menggunakan MASM 6.15 yang masih 16-bit dan simulator EMU8086 4.08.
Persiapan Software Assembler
• Pasang software MASM 6.15
• Download software dari https://winworldpc.com/home
• Ekstrak software ke dalam C:\>masm615
• Masukkan C:\>masm615\bin ke dalam Environment Variable
• Buka COMMAND.COM
• Pasang software EMU8086 4.08
• Download software dari
https://www.4shared.com/rar/wa8iHotqce/emu8086_408.html
• Ekstrak software ke dalam C:\>
• Klik ICON aplikasi EMU8086
 Program .COM
-----------------------------------------------------------
• Program .COM1) hanya menggunakan 1 segment (ukuran maksimal data + program
adalah 64KiB) dengan struktur Assembly sbb: .MODEL SMALL
.CODE
ORG 100H

Label1 : JMP Label2

+---------------------+
| TEMPAT DATA PROGRAM |
+---------------------+

Label2 : +---------------------+
| TEMPAT PROGRAM |
+---------------------+
• .MODEL SMALL : tanda directive untuk memberitahukan kepada Assembler
bentuk memori yang akan digunakan oleh program kita. INT 20H
1. TINY – Jika program Anda hanya menggunakan 1 segment seperti program COM. END Label1
Model ini disediakan khusus untuk program COM. -----------------------------------------------------------
2. SMALL – Jika data dan kode yang digunakan oleh program kurang dari ukuran 1 segment atau 64 KiB.
3. MEDIUM – Jika data yang digunakan kurang dari 64 KiB, tetapi kode bisa lebih dari 64 KiB
4. COMPACT – Jika data yang digunakan bisa lebih besar dari 64 KiB tetapi kode kurang dari 64 KiB
5. LARGE – Jika data dan kode yang dipakai oleh program bisa lebih dari 64 KiB
6. HUGE – Jika data, kode maupun array yang digunakan bisa lebih dari 64 KiB.
• JMP tujuan : digunakan untuk melompat menuju tempat yang ditunjuk. Pada struktur di atas dimaksudkan agar melewati tempat
data program, karena jika tidak ada perintah JUMP ini maka data program akan ikut dieksekusi sehingga kemungkinan besar akan
menyebabkan program Anda menjadi Hang.
• INT 20h : perintah Interupsi bernomor 20h berfungsi untuk mengakhiri program, mengembalikan status register2 dan
menyerahkan kendali sepenuhnya kepada DOS. Pada program COM cara ini bukanlah satu2nya, tetapi cara inilah yang paling
efektif untuk digunakan. Jika tidak diterminasi, program tidak akan tahu kapan harus selesai, komputer bisa menjadi hang.
1) Sebaliknya program EXE bisa lebih dari 1 segment. Mungkin ada yang bertanya-tanya mengapa pada progam COM yang dibuat digunakan model SMALL bukan
TINY ? Hal ini disebabkan karena banyak dari compiler bahasa tingkat tinggi yang tidak berkomunikasi dengan model TINY, sehingga kita gunakan model SMALL
sebagai pemecahannya.
Program .EXE
• Program EXE tidak dibatasi oleh satu segment sehingga ukurannya bisa lebih dari 64 KiB.
Akan tetapi karena program EXE bisa mengakses segment lain, maka perintah CALL dan
JMP menggunakan jenis FAR (program COM berbentuk NEAR) karena memerlukan
informasi alamat dari segment (CS) selain offset (IP). -----------------------------------------------------------
.MODEL SMALL

• Pada program COM, tidak perlu mendefinisikan .STACK 200h

.DATA
tempat tertentu untuk segment DATA dan STACK +--------------+

karena hanya menggunakan satu segment | Tempat |

| Data Program |
bersama CODE. Di sini STACK akan menggunakan +--------------+

akhir dari segment yang digunakan oleh .CODE

Label1:
segment CODE. Berbeda pada program EXE MOV AX,@DATA
ketiganya perlu didefinisikan. MOV DS,AX
+---------------+
| |
• Pada program EXE tidak perlu menggunakan | Tempat |
directive ORG 100h karena program EXE bisa | Program |

menempatkan dirinya pada alamat yang telah |

+---------------+
|

ditentukan. MOV AX,4C00h

INT 21h
END Label1

----------------------------------------------------------
• Pada program EXE, register segment CS dan SS diinialisasi secara otomatis, tetapi
register segment DS dan ES tidaklah demikian. Register segment DS dan ES pada
awalnya menunjuk pada awal program, yaitu PSP. Karenanya register DS perlu kita
inialisasi secara manual agar menunjuk pada segment data melalui perintah:
MOV AX, @DATA
MOV DS, AX
• Pada program EXE, kita perlu mendefinisikan tempat untuk stack. Pendefinisian tempat
untuk stack digunakan tanda directive: .STACK yang diikuti dengan banyaknya stack
yang didefinisikan untuk program. Pada model yang kita gunakan didefinisikan tempat
untuk stack sebanyak 200h Word yang tentunya sudah lebih dari cukup untuk
digunakan oleh program-program pada umumya.
• Berbeda dengan program COM, yang selalu kita akhiri dengan interupsi 20h, pada
program EXE interupsi 20h tidak bisa digunakan. Pada program EXE digunakan interupsi
21h fungsi 4Ch dengan register AL berisi kode return. Interupsi 21h fungsi 4Ch ini lebih
fleksibel untuk digunakan, karena selain kontrol akan dikembalikan kepada DOS, file-file
yang terbuka juga akan ditutup oleh fungsi ini. Fungsi ini juga akan mengembalikan
vektor interupsi default 22h, 23h dan 24h. Anda juga bisa mengakhiri program COM
dengan fungsi ini.
Menjalankan Program
Ketika Anda meminta sistem mengangkat (load) sebuah program .EXE dari disk ke
dalam memori untuk eksekusi, loader melakukan langkah2 berikut:
1. Mengakses program .EXE dari disk
2. Membangun program segment prefix (PSP) sebesar 256 byte (100h) pada
paragraph boundary (atau segment) yang tersedia dalam internal memori.
3. Menyimpan (store) program dalam memori berturutan langsung setelah PSP.
4. Mengangkat (load) alamat dari PSP dalam register2 DS dan ES.
5. Mengangkat (load) alamat dari code segment dalam register CS dan mengeset
register IP ke offset dari instruksi pertama (biasanya NOL) dalam code segment.
6. Mengangkat (load) alamat dari stack dalam register SS dan mengeset register
SP ke ukuran dari stack.
7. Mengalihakan kendali ke program untuk eksekusi, mulai (biasanya) dengan
instruksi pertama dalam code segment.
Terlihat bahwa program loader dengan benar menginisialisasi register2 CS:IP dan
SS:SP. Tetapi perhatikan bahwa program loader menaruh alamat PSP baik pada
register DS maupun ES, walaupun biasanya program Anda perlu alamat dari data
segment dalam register2 ini. Konsekuensinya, program .EXE Anda harus
menginisialisasi DS dengan mendefinisikan secara manual alamat data segment
dalam program.
Program Loading
Program2 diangkat (loaded) dengan utilitas bernama program loader. Setelah program diangkat, CPU
(IP/EIP/RIP) menunjuk ke titik masuk (entry point) program (yakni: main, start). Di sinilah umumnya disebut
sebagai langkah awal pogram, yaitu apa yang terjadi saat kita buka sebuah program (mis. dengan klik dua
kali)
1. OS mengambil (retrieve) informasi program seperti ukuran file dan lokasi fisik dalam disk.
2. OS menentukan lokasi yang tepat dalam memori, mengalokasikan ruang, dan menempatkan informasi
yang perlu dalam tabel descriptor.
3. OS memulai eksekusi instruksi pertama (entry point), lalu menjadi sebuah proses, yang diberikan
sebuah ID.
4. Proses berjalan bebas atau independen, dan OS merespons request2 proses untuk sumberdaya.
5. Ketika proses berakhir, memori dilepaskan.
5 Langkah Proses Pembuatan Program
1. Desain Algoritma
• Penetapan masalah
• Pengusulan solusi yang terbaik
• Pembuatan diagram skematik yang digunakan agar usulan solusi lebih baik à
flowchart Untuk membuat program dalam Bahasa Assembly tersedia dua
2. Pengkodean Algoritma opsi:
• Penulisan program dalam bahasa 1. Menggunakan Assembler (Microsoft Assembler MASM,
pemrograman tertentu (dalam Borland Turbo Assembler TASM, Netwide Assembler
hal ini Bahasa Assembly) NASM, GNU Assembler GAS, dst)
3. Penerjemahan ke Bahasa Mesin 2. Debugger
• Pembuatan program obyek, atau dengan kata lain program ditulis dalam suatu
deret/urutan 0 dan 1 yang dapat diinterpretasikan oleh prosesor.
4. Test Program
• Eksekusi program pada mesin komputer
5. Mengeliminasi Kesalahan Yang Terdeteksi
• Koreksi kesalahan umumnya memerlukan pengulangan seluruh langkah2 dari
Langkah 1 atau 2.
 Compiling, Linking and Executing Programs
loop: lw $t3, 0($t0)
lw $t4, 4($t0)
1 EDITING add $t2, $t3, $t4 Assembly program (text file)
sw $t2, 8($t0)
hello.asm addi
addi
$t0,
$t1,
$t0, 4
$t1, -1
source code
bgtz $t1, loop
Misal: VIDEO_IO.ASM
hello.asm 2 COMPILING
c:\>ml /c hello.asm

hello.obj Bisa berupa GAS, TASM,

3 LINKING 0x8d0b0000
0x8d0c0004 Assembler MASM, FASM, NASM,
c:\>link hello.obj 0x016c5020
0xad0a0008 GOASM, YASM
Machine code (binary) 0x21080004
0x2129ffff
0x1d20fff9
object code
hello.exe Misal: VIDEO_IO.OBJ
Firmware
4 EXECUTING/LOADING
Hardware
c:\>hello Registry, Memori, Device

Mikroprosesor atau mikrokontroler hanya mengenal Bahasa Mesin berupa 0 dan 1 sehingga Assembler
perlu mengkonversi Bahasa Assembly menjadi bahasa biner dan mengangkatnya (loading) atau
menyimpannya dalam memori sebelum program bisa dijalankan (eksekusi).
Relocatable vs Running Machine Language
Apa maksudnya “relocatable” machine language ?
• Ketika kode Assembly di-compile atau di-assemble menjadi object code, kode itu
dalam bentuk generik dimana instruksi pertama selalu mulai dari alamat 0x0h
dan alamat2 instruksi berikutnya adalah offset dari instruksi2 yang
mendahuluinya dalam ukuran byte.
• Ketika program diangkat (load) ke memori, instruksi pertama akan memiliki
alamat yang sah (legitimate address) dimana alamat instruksi2 berikutnya
merujuk berdasarkan offset dari situ.
Relocatable machine language Running machine language
_main: main:
00000000 b80a000000 movl $0xa, %eax 0x1fac <+0>: movl $0xa, %eax
00000005 48 decl %eax 0x1fb1 <+5>: decl %eax
00000006 bb05000000 movl $0x5, %ebx 0x1fb2 <+6>: movl $0x5, %ebx
0000000b c3 retl 0x1fb7 <+11>: retl
Format2 dari file objek menurut platform OS
Windows macOS Linux
COFF, PE, Win32, Win64 Mach-o ELF, a.out (deprecated)
Melihat Bentuk Assembly dari
Bahasa Tingkat Tinggi
• Gunakan C IDE dari CodeBlocks (http://www.codeblocks.org/downloads/26). Ambil
versi yang menyertakan GCC/G++ compiler dan GDB debugger dari TDM-GCC, mis.
codeblocks-17.12mingw-setup.exe
• Masukkan C:\Program Files\CodeBlocks\MinGW\bin dalam Environment Variable PATH.
• Buat program Bahasa Tingkat Tinggi: .file
.version
“ctest.c”
“01.01”
gcc2_compiled.:
• Lakukan kompilasi: #include <stdio.h>
.LC0:
.section .rodata
int main()
C:\>gcc –o ctest ctest.c { .text
.string “Hello, world!\n”

.align 16
C:\>dir printf(“Hello, world!\n”); .globl main
exit(0); .type main,@function
ctest.exe } main:
pushl %ebp
C:\>ctest movl %esp, %ebp
subl $8, %esp
C:\>Hello, world! relocatable machine language subl $12, %esp
pushl $.LC0
C:\>gcc –S ctest.c call
addl
printf
$16, %esp
C:\>type ctest.s subl
pushl
$12, %esp
$0
call exit
.Lfe1:
.size main,.Lfe1-main
.ident “GCC: (GNU) 2.96 20000731 (Linux-Mandrake 8.0 2.96-0.48mdk)”
$
 GNU Debugger gdb
• Selain DEBUG.COM bawaan Microsoft Windows, GNU debugger gdb juga dapat
digunakan untuk melacak program. Agar bisa didebug, executable file harus dikompilasi
dengan opsi –gstabs agar mengikutkan informasi penting dalam executable file sehingga
debugger mengetahui dimana dalam letak instruksi2 dalam kode sumber.
$ gcc -gstabs -o ctest ctest.c
$ gdb ctest Perintah Penjelasan
GNU gdb 5.0mdk-11mdk Linux-Mandrake 8.0
Copyright 2001 Free Software Foundation, Inc. break set breakpoint dalam kode sumber untuk menghentikan eksekusi
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions. set watchpoint untuk menghentikan eksekusi saat variabel
Type “show copying” to see the conditions. watch
There is absolutely no warranty for GDB. Type “show warranty” for details. mencapai nilai tertentu
This GDB was configured as “i386-mandrake-linux”... Mengamati elemen2 sistem yakni register2, stack dan memori
(gdb) info
(gdb) list
1 #include <stdio.h> x menguji lokasi memori
2
3 int main()
4 { print menampilkan nilai2 variabel
5 printf(“Hello, world!\n”);
6 exit(0);
run memulai eksekusi program dalam debugger
7 }
(gdb) break main
Breakpoint 1 at 0x8048496: file ctest.c, line 5. list mendaftar fungsi2 atau baris2 tertentu
(gdb) run
Starting program: /home/rich/palp/ctest
next melangkah ke instruksi berikutnya dalam program
Breakpoint 1, main () at ctest.c:5
5 printf(“Hello, world!\n”); melangkah ke instruksi berikutnya dalam program
(gdb) next step
Hello, world!
6 exit(0); cont melanjutkan eksekusi program dari titik berhenti
(gdb) next

Program exited normally. until jalankan program sampai ia mencapai baris kode sumber tertentu
(gdb)quit (atau lebih besar)
$
Program GNU Objdump
• GNU Objdump dibutuhkan agar programmer mampu melihat kode2 instruksi yang
dibangkitkan oleh compiler dalam file kode objek. Objdump bukan hanya menampilkan
kode bahasa assembly, tetapi kode2 instruksi raw (mentah) yang dibangkitkan.
• Agar compiler dapat membangkitkan file objek sehingga bisa di-dump, gunakan opsi –c:
$ gcc -c ctest.c
$ objdump -d ctest.o

ctest.o: file format elf32-i386

Disassembly of section .text:

00000000 <main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 08 sub $0x8,%esp
6: 83 ec 0c sub $0xc,%esp
9: 68 00 00 00 00 push $0x0
e: e8 fc ff ff ff call f <main+0xf>
13: 83 c4 10 add $0x10,%esp
16: 83 ec 0c sub $0xc,%esp
19: 6a 00 push $0x0
1b: e8 fc ff ff ff call 1c <main+0x1c>
$
 Program GNU Profiler
• Program GNU profiler (gprof) dipakai untuk menganalisa eksekusi program dan mementukan dimana “hot
spots” (titik2 panas) dalam aplikasi. Titik2 panas aplikasi adalah fungsi2 yang memerlukan jumlah waktu
pemrosesan paling banyak saat program berjalan. Seringkali ini berupa fungsi2 intensif matematis, tetapi
tidak selalu. Fungsi2 yang intensif I/O juga meningkatkan waktu pemrosesan.
• Agar aplikasi gprof bisa digunakan, Anda perlu memastikan fungsi2 yang akan dimonitor dikompilasi
menggunakan parameter –pg. Parameter ini mengompilasi source code, memasukkan sebuah call ke
subrutin mcount bagi setiap fungsi dalam program. Saat aplikasi berjalan, subrutin mcount membuat
sebuah call graph profile file bernama gmon.out, yang berisi informasi timing setiap fungsi dalam aplikasi.
#include <stdio.h> % cumulative self self total
$ gcc -o demo demo.c -pg
void function1()
time seconds seconds calls us/call us/call name
{
$ ./demo 67.17 168.81 168.81 50000 3376.20 5023.11 function2
int i, j; $ 32.83 251.32 82.51 50100 1646.91 1646.91 function1
for(i=0; i <100000; i++)
j += i;
$ ls -al gmon.out
} -rw-r--r-- 1 rich rich 426 Jul 7 12:39 gmon.out
void function2()
{ $ gprof demo > gprof.txt
int i, j; $
function1();
for(i=0; i < 200000; i++) index % time self children called name
j = i; <spontaneous>
} [1] 100.0 0.00 251.32 main [1]
168.81 82.35 50000/50000 function2 [2]
int main() 0.16 0.00 100/50100 function1 [3]
{ -----------------------------------------------
int i, j; 168.81 82.35 50000/50000 main [1]
for (i = 0; i <100; i++) [2] 99.9 168.81 82.35 50000 function2 [2]
function1(); 82.35 0.00 50000/50100 function1 [3]
-----------------------------------------------
for(i = 0; i<50000; i++) 0.16 0.00 100/50100 main [1]
function2(); 82.35 0.00 50000/50100 function2 [2]
return 0; [3] 32.8 82.51 0.00 50100 function1 [3]
} -----------------------------------------------
Anda sudah siap berpetualang Bahasa Assembly !
Bahan dapat diakses di: http://bit.ly/2pGn6Cl