Pask - 2 - 14S16040 - Basry Sihotang

Modul 2
Pointer, Structure, Array, dan

Operasi dalam Level BIT
Basry A Sihotang (14S16040)
Tanggal Percobaan : 11/10/2018
[ELS 2102] [Praktikum Arsitektur Sistem Komputer]
[Laboratorium Dasar Teknik Elektro] – Teknik Elektro
Institut Teknologi Del
menyimpan data tersebut dalam memory. Terdapat beberapa

Abstrak— Dengan melakukan praktikum percobaan II ini, tipe data yang telah tersedia dalam bahasa C. Tipe data yang
maka diharapkan mampu memahami representasi dari tersedia ini disebut simple data type.
informasi dalam level bit yang disimpan dalam memory, mampu Masing-masing tipe data memiliki ukuran yang berbeda-
menggunakan operator-operator bitwise dalam bahasa C untuk beda untuk disimpan di dalam memory. Dalam bahasa C, kita
mengolah informasi yang tersimpan dalam memory, mampu
dapat menggunakan sintaks sizeof untuk mengetahui besar
memahami fungsi pointer dan mampu menggunakan pointer
untuk melakukan pengolahan data di dalam memory, mampu tipe data tersebut di dalam memory.
memahami array beserta representasinya dalam memory dan
pengolahan informasinya dalam bahasa C, serta memahami Tipe Data Ukuran Rentang Nilai
structure beserta representasinya dalam memory dan Char 1 Byte -128 - 127
pengolahannya dalam basaha C. Adapun software yang Unsigned Char 1 Byte 0 – 255
digunakan dalam pemenuhan praktikum ini adalah GNU C Signed Char 1 Byte -128 – 127
Compiler (GCC), CodeBlock, Notepad++, HexEdit.
Short 2 Byte -32768 – 32767
Keywords— Pointer, Array, Structure, Bitwise
Unsigned Shor 2 Byte 0 – 65535
Signed Short 2 Byte -32768 – 32767
Int 4 Byte -2147483648 –
I. INTRODUCTION 2147483647
Unsigned Int 4 Byte 0 – 4294967295
T erdapat beberapa tujuan yang hendak dicapai melalui
percobaan ini. Berikut adalah tujuan praktikum ini :
1. Praktikan memahami representasi informasi dalam
Signed Int 4 Byte -2147483648
2147483647
–
Long 4 Byte -2147483648 –

level bit yang disimpan pada memory 2147483647
2. Praktikan mampu menggunakan operator-operator Unsigned Long 4 Byte 0 – 4294967295
bitwise dalam bahasa C untuk mengolah informasi Signed Long 4 Byte -2147483648 –
yang tersimpan dalam memory 2147483647
3. Praktikan memahami fungsi pointer dan mampu
menggunakan pointer untuk melakukan pengolahan Long Long 8 Byte -9223372036854775808
data di dalam memory. –
4. Praktikan memahami array beserta representasinya 9223372036854775807
dalam memory dan pengolahan informasinya dalam
bahasa C Unsigned Long 8 Byte 0 –
5. Praktikan memahami structure beserta Long 18446744073709551615
representasinya dalam memory dan pengolahannya
dalam bahasa C Signed Long 8 Byte 9223372036854775808
Long –
9223372036854775807
II. LANDASAN TEORETIS
Float 4 Byte ?
Tipe data merupakan represenasi data yang disimpan dalam
Double 8 Byte ?
memory. Tipe data menentukan operasi yang dapat dilkaukan
pada suatu data bertipe tertentu, rentang nilai yang mungkin
dimiliki oleh data bertipe tertentu, arti dari data, dan cara
Dengan adanya perbedaan ukuran masing-masing tipe data, tersebut). Kita dapat menggunakan pointer untuk
diperlukan sebuah mekanisme alignment pada memory agar melakukannya. Beberapa mesin juga membutuhkan alignment
setiap data tersusun dengan baik di dalam memory dan dapat data pada memory secara spesifik sehingga ukuran structure
diproses oleh mikroprosesor. Dengan alignment, data-data dapat berbeda karena compiler secara otomatis melakukan
variabel disimpan dalam lokasi memory yang memiliki alignment data-data pada structure, contohnya dengan
address offset yang berupa kelipatan dari ukuran word. Hal ini padding.
akan menambah performance karena data disusun sesuai cara Array merupakan kumpulan lokasi penyimpanan data yang
mikroprosesor menggunakan memory. kontigu (berurutan) dengan tipe data yang sama. Setiap lokasi
OPERATOR BITWISE DALAM BAHASA C penyimpanan dalam sebuah array disebut elemen array. Array
Bahasa C mendukung pengolahan informasi dalam level bit dialokasikan secara sekaligus dalam memory sesuai dengan
menggunakan operator bitwise. Berbeda dengan operator level ukurannya. Karena letak elemen yang berurutan, akses elemen
byte, operator bitwise akan mengoperasikan data untuk setiap array pada memory relatif lebih mudah dan cepat
bit. Sedangkan operator level byte, data akan diolah dalam dibandingkan dengan struktur data Linked- List. Setiap
bentuk 1 byte (1 byte = 8 bit). Operator bitwise dapat elemen dalam array dapat diakses menggunakan indeks yang
digunakan pada berbagai tipe data seperti char, int, short, long, biasanya berupa bilangan bulat skalar bukan negatif. Dalam
atau unsigned. Operator-operator bitwise dalam bahasa C bahasa C, elemen pertama dalam array diberi indeks 0.
didefinisikan sebagai berikut. Representasi array dalam memory dengan deklarasi int nim[8]
Simbol Operator adalah sebagai berikut (asumsikan address elemen ke-0 adalah
& Bitwise AND 0x4000 dengan nilai elemen pertama adalah 1, nilai elemen
| Bitwise Inclusive OR kedua adalah 3, nilai elemen ketiga adalah 2, nilai elemen
^ Bitwise Exclusive OR keempat adalah 1, nilai elemen kelima adalah 1, nilai elemen
<< Left Shift keenam adalah 0, nilai elemen ketujuh adalah 0, dan nilai
>> Right Shift elemen kedelapan adalah 7).
~ Bitwise NOT Nila 1 3 2 1 1 0 0 7
Bahasa C juga memiliki operator logika AND, inclusive i
OR, dan NOT. Operator ini sering tertukar dengan operator Ala 0x4 0x4 0x4 0x4 0x4 0x4 0x4 0x4
bitwise. Operator logika tersebut diberikan sebagai berikut. mat 000 004 008 00C 010 014 018 01C
Pada operasi logika, setiap argumen bukan nol Inde nim nim nim nim[ nim nim nim nim[
merepresentasikan TRUE, sedangkan argumen nol ks [0] [1] [2] 3] [4] [5] [6] 7]
merepresentasikan FALSE. Ekspresi logika akan
mengembalikan nilai 1 untuk TRUE dan nilai 0 untuk FALSE. Bahasa C mendukung deklarasi array secara statis maupun
Simbol Operator secara dinamis. Array statis memiliki ukuran yang tidak bisa
&& Logical AND diubah-ubah sedangkan array dinamis memiliki ukuran yang
|| Logical OR dapat ditentukan saat program sedang berjalan. Array dinamis
! Logical NOT dapat dideklarasikan dengan contoh int pusheen[]. Dengan
Khusus untuk operator Right Shift, terdapat dua jenis demikian pusheen merupakan array yang memiliki elemen
operator Right Shift, yaitu Logical Right Shift dan Arithmetic bertipe integer namun dengan banyak elemen yang belum
Right Shift. Logical Right Shift akan mengisi bit MSB dengan didefinisikan. Untuk melakukan alokasi terhadap array
nilai 0 sementara Arithmetic Right Shift akan mengisi bit pusheen, kita dapat menggunakan perintah malloc atau calloc
MSB sesuai dengan tanda (sign) variabel tersebut menurut dalam bahasa C. Untuk mengubah ukuran array dinamis yang
aturan two’s complement. Untuk Left Shift, tidak ada telah dialokasikan, kita dapat menggunakan perintah realloc.
perbedaan antara Logical Left Shift dan Arithmetic Left Shift. Untuk melakukan dealokasi array dinamis, kita dapat
Pada umumnya, seluruh mesin dapat mendukung dua jenis menggunakan perintah free. Perhatikan bahwa pada beberapa
operator Right Shift dan Left Shift ini. kasus, perintah realloc dapat menyebabkan program tidak
efisien contohnya saat array diubah ukurannya menjadi lebih
STUCTURE besar dan sistem harus melakukan pemindahan elemen-elemen
Structure (struct) merupakan complex data type yang array ke posisi memory yang baru agar perbesaran ukuran
mendefinisikan daftar variabel yang akan ditempatkan dalam array dapat dilakukan.
blok memory menggunakan satu nama. Dengan demikian, Array juga dapat memiliki elemen array berupa array.
setiap variabel berbeda pada structure dapat diakses Dengan demikian, kita dapat mendefinisikan array n-dimensi.
menggunakan sebuah single pointer atau dengan Contohnya, sebuah matriks merupakan array dengan dua
menggunakan nama structure itu sendiri. Pada structure, dimensi. Array tersebut memiliki elemen array berupa array,
masing-masing variabel disimpan dalam blok memory yang contohnya int pusheen[][5] atau int pusheen[4][5]. Namun,
kontigu yang biasanya memiliki delimiter berupa panjang karena memory komputer bersifat linear, komputer akan
word. Kita juga dapat menggunakan sintaks sizeof untuk menyimpan array n-dimensi dalam bentuk linear juga. Hal ini
memeriksa ukuran structure yang kita definisikan. Perlu menyebabkan kita harus memperhatikan urutan indeks untuk
diingat bahwa bahasa C tidak mengizinkan kita melakukan mengakses setiap elemen array n-dimensi karena hal ini akan
deklarasi rekursif terhadap structure (sebuah structure tidak berpengaruh terhadap performance dari program yang kita
boleh berisi structure bertipe yang sama dengan structure buat terlebih data array yang diolah cukup besar, contohnya
seberapa baikkah program yang kita buat dalam 1 0 1
memanfaatkan cache memory (cache-friendly). 1 1 0
Dengan menggunakan fungsi :
POINTER y = ~((~(~x&y))&(~(x&~y)))
Pointer merupakan variabel yang menyimpan alamat Truth table yang dihasilkan adalah :
memory. Dengan kata lain, pointer memiliki nilai alamat x y A= B=x&~y C=~A&~B ~C
memory untuk melakukan referensi terhadap suatu objek yang
~x&y
tersimpan dalam memory komputer. Dengan menggunakan
0 0 0 1 1 0
pointer, kita dapat memiliki akses terhadap memory secara
langsung. Untuk setiap tipe data T, terdapat pointer ke T. 0 1 0 0 0 1
Deklarasi pointer dalam bahasa C dapat dilakukan dengan 1 0 1 0 0 1
mudah, contohnya int *ptr yang merupakan pointer yang 1 1 0 1 1 0
melakukan referensi terhadap objek bertipe integer. Dapat terlihat bahwa hasil keluaran dari fungsi y
Pointer juga dapat digunakan untuk menunjukkan structure menghasilkan output yang sama dengan output dari fungsi
berdasarkan alamatnya di memory. Hal ini sangat berguna XOR. Dari pernyataan ini, dapat dibuktikan bahwa formula y
untuk melakukan passing structure ke atau dari sebuah fungsi dikatakan benar
hanya dengan memberikan alamat structure tersebut di
memory. Pointer ini juga dapat di-dereferensi seperti halnya B. Percobaan II : Fungsi Ekstraksi Byte
pointer lain dalam bahasa C, yaitu menggunakan operator Data :
dereference (*). Selain itu, juga terdapat operator yang sangat
berguna yaitu struct_name -> member untuk melakukan
dereferensi pointer-to-struct lalu mengakses nilai dari anggota
structure tersebut. Operator tersebut memiliki ekuivalensi
dengan (*struct_name).member. Sebetulnya, sebuah fungsi
dapat langsung mengembalikan sebuah structure walaupun hal
ini terkadang tidak efisien saat dijalankan.
Dalam array, indeks biasanya didefinisikan sebagai
perhitungan matematika terhadap alamat pointer. Dengan
demikian penulisan array[i] memiliki ekuivalensi dengan
*(array + i). Perhitungan matematika terhadap pointer untuk
mengakses setiap elemen array dapat dilakukan karena array Analisis :
memiliki elemen yang tersusun secara kontigu (berurutan Dalam percobaan ini, dilakukan ekstraksi byte ke-n dari
tanpa jeda). suatu data X yang diinput dari user dengan ukurannya tertentu.
Urutannya diberi nomor 0 untuk LSB hingga 2 untuk MSB.
III. HASIL DAN ANALISIS Dari data yang diperoleh dengan inputan 12345678 dan
Berdasarkan percobaan yang telah dilakukan, diperoleh ekstraksi ke 1 diperoleh keluaran x56. Pada program ini
beberapa data. terlihat bahwa proses ekstraksi dilakukan dengan
memanfaatkan operator bitwise pada setiap bitnya. Operator
A. Percobaan 1: Fungsi XOR
tersebut akan menggeser sejauh n byte sehingga byte yang
Data : akan diambil berada pada posisi LSB. Kemudian dilakukan
manipulasi dengan operasi AND 0xFF sehingga byte selain
yang berada pada LSB akan menjadi 0.
C. Percobaan III : Fungsi Masking Byte
Data :
Analisis :
Pada percobaan ini, dilakukan sebuah algoritma untuk
mengeluarkan logika fungsi XOR dengan memanfaatkan
operator bitwise AND dan operator bitwise NOT.
Keluaran dari fungsi XOR adalah :
A B A^B Analisis :
0 0 0 Dalam percobaan ini, dilakukan masking dengan aturan
0 1 1 bahwa seluruh bit mulai dari batas atas hingga batas bawah
diset menjadi 1 sedangkan bit lainnya di set menjadi 0. Dalam dicerminkan menjadi (-) dengan operasi ~y+1. Kemudian
data diatas, inputan diminta batas atas 5 dan batas bawahnya dilakukan operasi pengurangan bilangan pertama dengan
3. Dan hasil yang diperoleh dari masking adalah x38. Pada bilangan kedua dengan operator penjumlahan (+). Dan
operator fungsi pada program awalnya diset suatu bit bernilai eksekusi terakhir adalah dengan melakukan AND antara hasil
1. Kemudian dilakukan shift sebanyak 31 kali. Kemudian akan pengurangan tersebut dengan 0xFF, agar menghasilkan
melakukan shift kanan sebanyak selisih antara batas atas dan hexadesimal.
batas bawah. Dan yang terakhir adalah melakukan shift right
F. Percobaan VI :Fungsi Shift Register
sebanyak 31-batas atas pada byte.
Data :
D. Percobaan IV : Fungsi Membalik Ukuran Byte

Data :
Analisis :
Dalam percobaan ini, dilakukan fungsi shift register, atau
kata lain adalah menggeser byte. Diasumsi bahwa banyak bite
Analasis : adalah 32 dan setiap nilai yang dimasukkan secara bergantian
Pada percobaan ini, dilakukan membalik urutan dari byte. adalah 5 bit. Awal diset shift register dengan 0x00000000.
Dalam data diatas, inputan dari user adalah 0x01020304 dan Kemudian akan bergeser sesuai dengan inputan dari user.
memperoleh output nya 0x04030201. Dalam programnya Dalam data, inputan dari user adalah 0x04, dan hasil shift
dilakukan penukrana byte ke-0 dengan byte ke-3 dan byte ke-2 adalah 0x00000004. Dan yang kedua adalah inputannya 0x93
dengan byte ke-1. Hal pertama yang dieksekusi adalah dan hasil shifting adalah 0x00000093. Dari program yang
pemisahan byte dengan melakukan operasi AND antara telah dibuat, dilakukan menggeser nilai awal sebanyak 5 bit ke
bilangan denga 0xFF. Kemudian, dilakukan penukaran posisi kiri kemudian selanjutnya melakuakn operasi OR terhadap
byte ke 3 di shift menjadi byte ke 0 dan juga sebaliknya. input nilai yang diberikan.
Setelah penukaran terjadi, selanjutnya yang dieksekusi adalah
G. Percobaan VII : Program Enkripsi Sederhana
return nilai hasil penjumlahan keempat byte tersebut.
Data :
E. Percobaan V : Fungsi Pengurangan Byte
Data :
Analisis :
Analisis : Fungsi ekripsi dilakukan byte per byte. Untuk byte
Untuk percobaan ini, dilakukan operasi pengurangan byte. pertama, hasil dari variabel angka yang di XOR dengan
Pengurangan dari byte pertama dengan byte kedua. Inputan variabel desimal kemudian dilakukan operasi AND dengan
kedua byte ini merupakan inputan dari user secara langsung, 0xFF sehingga diperoleh hasil untuk byte pertama. Untuk byte
yang kemudian dieksekusi dan menghasilkan output yang kedua, terlebih dahulu dilakuakn shift right sebanyak 8
pengurangan dari kedua byte. Dari data diatas, inputan dari byte kemudian di XOR dengan variabel desimal dan
user adalah 0x15 sebagai byte pertama dan 0x07 sebagai byte selanjutnya dilakukan shift left sebanyak 8byte. Dan yang
kedua. Dan outputnya adalah 0x0E. Dan benar bahwa byte terakhir adalah dilakukan operasi AND dengan 0xFF.
0x15 – 0x07 adalah 0x0E. Hal yang dilakukan pada program Sedangkan untuk byte ketiga dan keempat, operasinya yang
adalah algoritma yang digunakan dengan melakukan shift kiri dilakukan sama dengan yang dilakukan pada byte kedua
yang kemudian dilakukan shift kanan pada bilangan yang namun dilakukan shift sebanyak 16 byte pada byte ke-tiga dan
pertama dan juga yang kedua. Lalu bilangan kedua 24 byte untuk byte ke-empat. Setelah diperoleh nilai untuk
setiap byte hasil, kemudian dilakukan return dari hasil .def _coba; .scl 2; .type
pernjumlahan byte tersebut. 32; .endef
_coba:
H. Percobaan VIII : Pointer dalam Assembly pushl %ebp
Data : movl %esp, %ebp
.file "pointerdanassembly.c" subl $32, %esp
.text movl 8(%ebp), %eax
.globl _coba movl 4(%eax), %edx
.def _coba; .scl 2; .type movl (%eax), %eax
32; .endef movl %eax, -8(%ebp)
_coba: movl %edx, -4(%ebp)
pushl %ebp movl 12(%ebp), %eax
movl %esp, %ebp movl 4(%eax), %edx
subl $16, %esp movl (%eax), %eax
movl 8(%ebp), %eax movl %eax, -16(%ebp)
movl (%eax), %eax movl %edx, -12(%ebp)
movl %eax, -4(%ebp) movl 16(%ebp), %eax
movl 12(%ebp), %eax movl 4(%eax), %edx
movl (%eax), %eax movl (%eax), %eax
movl %eax, -8(%ebp) movl %eax, -24(%ebp)
movl 16(%ebp), %eax movl %edx, -20(%ebp)
movl (%eax), %eax fldl -8(%ebp)
movl %eax, -12(%ebp) faddl -16(%ebp)
movl -8(%ebp), %eax fstpl -32(%ebp)
addl -4(%ebp), %eax movl 12(%ebp), %ecx
movl %eax, -16(%ebp) movl -32(%ebp), %eax
movl 12(%ebp), %edx movl -28(%ebp), %edx
movl -16(%ebp), %eax movl %eax, (%ecx)
movl %eax, (%edx) movl %edx, 4(%ecx)
movl 16(%ebp), %edx movl 16(%ebp), %ecx
movl -8(%ebp), %eax movl -16(%ebp), %eax
movl %eax, (%edx) movl -12(%ebp), %edx
movl 8(%ebp), %edx movl %eax, (%ecx)
movl -12(%ebp), %eax movl %edx, 4(%ecx)
movl %eax, (%edx) movl 8(%ebp), %ecx
leave movl -24(%ebp), %eax
ret movl -20(%ebp), %edx
.def ___main; .scl 2; .type movl %eax, (%ecx)
32; .endef movl %edx, 4(%ecx)
.globl _main leave
.def _main; .scl 2; .type ret
32; .endef .def ___main; .scl 2; .type
_main: 32; .endef
pushl %ebp .globl _main
movl %esp, %ebp .def _main; .scl 2; .type
subl $8, %esp 32; .endef
andl $-16, %esp _main:
movl $0, %eax pushl %ebp
movl %eax, -4(%ebp) movl %esp, %ebp
movl -4(%ebp), %eax subl $8, %esp
call __alloca andl $-16, %esp
call ___main movl $0, %eax
movl $0, %eax movl %eax, -4(%ebp)
leave movl -4(%ebp), %eax
ret call __alloca
call ___main
movl $0, %eax
.file "pointerdanassembly_double.c" leave
.text ret
.globl _coba
Analisis :
Awalnya, penggunaan memory dari kedua program adalah
memory yang sudah berbeda (alokasi). Dalam tipe data integer
terdapat sub1 $16, %esp sedangkan pada tipe data double
sub1 $32, %esp. Hal ini disebabkan karena tipe data
yang digunakan berbeda.
I. Percobaan IX : Fungsi Membalik Urutan Array
Data :
Analisis :
Dalam program yang telah dicantumkan dalam lampiran
dibawah, variabel yang digunakan adalah char
*nama[10]. Hal ini berarti dapat dideklarasi sederet array
yang berupa pointer to array of char. Optimasi memory yang
dilakukan yaitu ketika awal program hanya dialokasikan
memory yang cukup menampung char dengan maksimum 10
character. Selanjutnya setiap input nama akan dialokasikan
memory untuk menampung nama sebanyak 10 char. Hal ini
menyebabkan memory yang dialokasikan bergantung dengan
jumlah inputan.
Analisis:
L. Percobaan XII : Perkalian Matriks
Dalam program dilakukan fungsi looping untuk menerima
input dari user dengan satu persatu akan disimpan dalam array Data :
yang sudah disediakan diawal dalam penginisialisasian. Dan
kemudian dilakukan penampilan karakter tersebut secara
terbalik dengan menggunakan fungsi looping juga.
J. Percobaan X : Matriks Nama
Data :
Analisis :
Cara kerja program yaitu dengan melakukan validasi syarat
perkalian matriks. Yakni jumlah kolom matriks pertama harus
sama dengan baris matriks kedua. Apabila syarat tak terpenuhi
maka akan ditampilkan tidak terpenuhi.
Kemudian kedua matriks diisi nilainya dengan
menggunakan looping. Kemudian dilakukan perkalian matriks
dengan memanggil fungsi perkalian (mullMatriks). Pada saat
Analisis: pemanggilan fungsi, hanya dilempar vatiable nama matriks.
Dalam percobaan ini, dilakuakan membalikkan matriks dari Hal ini dilakukan karena variable nama matriks sudah
nama. Pada program dilakukan inisialisasi dari tipe data char menunjukan alamat matriks, bukan nilainya. Sehingga apabila
dengan dua dimensi char nama[5][100] . Kemudian diubah didalam funsgi maka variable local pada main akan
akses untuk pengisian dari tipe data char nama tersebut dan ikut berubah.
penulisan char dilakukan seperti menggunakan array pada
M. Percobaan XIII: Penjumlahan Biner dengan Array
umumnya.
Data :
K. Percobaan XI : Matriks Nama dengan Pointer
Data :
mengakibatkan urutan indeks harus diperhatikan juga untuk
mengakses setiap elemen array n-dimensi karena hal ini akan
berpengaruh pada performance dari program yang akan
dibuat, terutama apabila data array yang diolah cukup besar.
Operasi-operasi yang dapat dilakukan pada operasi level bit
(bitwise) dalam Bahasa C antara lain operasi AND (&),
inclusive OR ( | ), exclusive OR( ^ ), left shift (<<), right shift
(>>), dan NOT (~).
Pada system bilangan two’s complemen, operasi
pengurangan dilakukan dengan cara menjumlahkan bilamgan
Analisis : pertama dengan nilai negative dari bilangan kedua. Missal
Pada tugas 13, dibuat sebuah program yang dapat bilangan pertama adalah x, dan bilangan kedua adalah y. maka
melakukan simulasi operasi penjumlahan pada level bit operasi pengurangan yaitu x + (-y). Dengan –y diperoleh dari
dengan representasi two’s complement menggunakan array. ~y+1.
Array yang digunakan terdiri dari 8 bit dan hanya boleh diisi Pointer merupakan variabel yang menyimpan alamat
dengan angka 1 dan 0. Contohnya, misalkan penjumlahan memory. Dengan kata lain, pointer memiliki nilai alamat
antara 7 dan 8. Angka 7 akan dimasukan kedalam array memory untuk melakukan referensi terhadap suatu objek yang
berurutan untuk setiap bit menjadi 00000111 dan angka 8 akan tersimpan dalam memory komputer. Dengan menggunakan
dimasukan ke dalam array berurutan untuk setiap bit menjadi pointer, kita dapat memiliki akses terhadap memory secara
00001000. Kemudian hasil penjumlahannya adalah 00001111. langsung. Pointer juga dapat digunakan untuk menunjuk
Hasil pejumlahan ini kemudian diubah menjadi bilangan structure berdasarkan alamanya di memory. Selain itu pointer
decimal dengan membaca isi array tersebut. juga dapat di-dereferensi seperti halnya pointer lain dalam
Kode program terlampir. Proses yang digunakan pada Bahasa C.
program yaitu pertama-tama dibuat representasi bit dalam Perkalian matriks yang dipilih yaitu dengan prototype struct
array dari input yang diberikan . Hal ini dilakukan dengan Matriks mulMatriks (struct Matriks A, struct Matriks B).
memanfaatkan fungsi getBit(x,i) . Kemudian dilakukan Prototype fungsi tersebut dipilih karena matriks hasil perkalian
simulasi penjumlahan dengan aturan two’s complement. dalam fungsi sesuai dengna dimensi matriks perkalian tersebut
Selanjutnya array berisi bit hasil penjumlahan diubah kembali (array dinamis). Selain itu, jumlah parameter fungsi tidak
menjadi bilangan biner dengan menggunakan fungsi int bitDes banyak karena matriks disimpan dalam suatu struct sehingga
(int *A). Untuk prose pengurangan, hal yang sama dilakukan penggunaan memori dapat diminimalisasi.
seperti pada proses pengurangan namun dengna mengubah
bilangan biner kedua menjadi –y (= ~y+1) terlebih dahulu
kemudian dijumlahkan dengan bilangan pertama.
Analisis Pertanyaan :
Representasi tipe data float dan double dalam memory yaitu
float merupakan tipe data floating point ukuran 32 bit (4
bytes) sedangkan double merupakan tipe data floating point
ukuran 64 bit (8 bytes)
Urutan penulisan structure menentukan ukuran structure
karen pada computer 32-bit, work size sebanyak 4 byte yang
berarti memory akan diproses per-4-byte.
Perbedaan array dan structure yaitu array merupakan
kumpulan lokasi penyimpanan data yang kontinu (berurutan)
dengan tipe data yang sama. Sedangakan structure merupakan
complex data type yang mendefinisikan daftar variable yang
akan ditempatkan dalam blok memory menggunakan satu
nama.
Array statis memiliki ukuran yang tidak dapat diubah-ubah
sedangkan array dinamik memiliki ukuran yang dapat
ditentukan saat program sedang berjalan.
Setiap elemen dalam array dapat diakses menggunakan
indeks yang biasanya berupa bilangan bulat scalar atau
negative. Dalam Bahasa C, elemn pertama dalam array diberi
indeks 0. Representasi array dalam memory dengan deklarasi
int nim [8].
Array juga dapat memiliki elemen array berupa array
sehingga dapat didefinisikan array n-dimensi. Namun karena
memory computer bersifat linier, maka computer akan
menyimpan array n-dimensi dalam bentuk linier juga. Hal ini
IV. SIMPULAN
 Suatu informasi disimpan dalam memory dengan
representasi sesuai dengan tipe datanya. Ukutan tipe
data berbeda-beda disebabkan adanya address offset
dalam memori sehingga digunakan padding untuk
mengisi blok kosong.
 Operator bitwise dapat digunakan untuk pengolahan
data secara langsung dalam level bit pada memory.
Operasi bitwise ini relative lebih cepat dibandingkan
dengan fungsi bawaan atau fungsi buatan yang
bekerja pada high level.
 Pointer digunakan sebagai penunjuk suatu alamat
dengan data tertentu. Pointer dapat digunakan sebagai
pengubah nilai suatu variable local fungsi dari fungsi
lain. Selain itu dapat digunakan pula untuk
optimalisasi penggunaan memory (karena mirip
dengan array dinamik)
 Array adalah suatu data dengan tipe data tertentu
yang tersusun secara berurutan dengan alamat yang
berurutan pula. Array berdimensi satu, dua, atau
tiga.Untuk array berdimensi dua dalam bentuk table,
namun representasinya pada memory tetap sebaris
namun bersusun menurut baris dan kolom.
 Structure dapat digunakan untuk membentuk suatu
tipe data bentukan agar lebih mudah digunakan
dalam program. Selain itu dalam penyusunan variable
pada structure, perlu memperhatikan ukuran dari
masing-masing variable dan urutan deklarasinya agar
diperoleh penggunaan memori yang optimal dengan
padding seminimal mungkin.
REFERENSI
[1].
Bryant, Randal, dan David O’Hallaron. Compuer
Systems : A Programmer’s Perspective 2nd Edition.
2011 Massachusetts : Person Education Inc.
Patterson,
[2].
David, dan John Hennessy. Computer Organization
and Desigh : The Hardware/Software Interface.
2012. Waltham : Elsevier Inc.
LAMPIRAN
1. Source Code Percobaan 1

// Praktikum NWS3102 Arsitektur Sistem Komputer
// Modul : 02
// Percobaan : Fungsi XOR
// Tanggal : 10 Oktober 2018
// Kelompok : -
// Nama : Basry A Sihotang (14S16040)
// Nama File : bitXOR.c
// Deskripsi : Merepresentasikan keluaran XOR dengan menggunakan logika bitwise And
dan bitwise NOT
#include<stdio.h>
//#include<stdlib.h>
int bitXOR (int a, int b){

int result;
result = ~(~(~a&b)&~(a&~b));
return result;
}

// Modul : 02
// Kelompok : -
// Nama File : bitXOR.h
dan bitwise NOT
#ifndef fungsiXOR
#define fungsiXOR
int bitXOR (int a, int b);
#endif

// Modul : 02
// Kelompok : -
// Nama File : main.c
dan bitwise NOT
#include <stdio.h>
#include "bitXOR.h"
int main (void){

int a,b,c;
printf("Masukkan nilai a dan b berturut turut: "); scanf("%d %d", &a, &b);
c=bitXOR(a,b);
printf("Result a XOR b = %d", c);
return 0;
}
2. Source Code Percobaan 2 :
// Modul : 02
// Kelompok : -
// Nama File : getbyte.c
dan bitwise NOT
#include<stdio.h>
#include "getbyte.h"
int getbyte (int angka, int ekstraksi){

switch (ekstraksi){
case 0 :
return ((unsigned) (angka & 0X000000FF)) >> 0;
case 1 :
return ((unsigned) (angka & 0X0000FF00)) >> 8;
case 2 :
return ((unsigned) (angka & 0X00FF0000)) >> 16;
case 3 :
return ((unsigned) (angka & 0XFF000000)) >> 24;
}
}

// Modul : 02
// Kelompok : -
// Nama File : getbyte.h
dan bitwise NOT
#ifndef GETBYTE
#define GETBYTE
int getbyte(int angka, int ekstraksi);
#endif

// Modul : 02
// Kelompok : -
dan bitwise NOT
#include <stdio.h>
int main (){

int angka, ekstraksi,result;
printf("Masukkan Angka yang ingin diektraksi : "); scanf ("%x", &angka);
printf("Masukkan ekstraksi ke berapa : "); scanf ("%d", &ekstraksi);
result = getbyte (angka,ekstraksi);
printf ("Result : 0x%x", result);
return 0;
}

// Modul : 02
// Kelompok : -
// Nama File : bitmask.c
dan bitwise NOT
#include <stdio.h>
#include "bitmask.h"
int bitmask(int highbit, int lowbit);

int bitmask(int highbit, int lowbit){
int x,y,batas = highbit - lowbit;
unsigned mask;
if (batas < 1) return 0;
else {
mask = (1<<31)>>batas;
x=1<<31;
printf("%x\n", x);
y=x>>batas;
printf("%x\n",y);
printf("%x\n", mask);
return (mask >> (31-highbit));
}
}

// Modul : 02
// Kelompok : -
// Nama File : bitmask.h
dan bitwise NOT
#ifndef BITMASK
#define BITMASK
int bitmask(int highbit, int lowbit);
#endif

// Modul : 02
// Kelompok : -
dan bitwise NOT
#include <stdio.h>
int main (){

int angka_1, angka_2;
printf("Masukkan angka pertama dan kedua secara berturut-turut : "); scanf
("%d %d", &angka_1, &angka_2);
printf("Hasil masking : 0x%x", bitmask(angka_1,angka_2));

// Modul : 02
// Kelompok : -
dan bitwise NOT
#include <stdio.h>
#include "reversebyte.h"
int main (void){

int x;
printf("Masukkan angka yang ingin di reverse : 0x"); scanf ("%x",&x);
printf("Hasil Reverse urutan byte : 0x0%x",reversebyte(x));
}

// Modul : 02
// Kelompok : -
// Nama File : reversebyte.c
dan bitwise NOT
#include <stdio.h>
#include "reversebyte.h"
int reversebyte (int x){

unsigned byte3 = (x & 0xFF000000);
// printf("%x\n",byte3);
unsigned byte2 = (x & 0x00FF0000);
unsigned byte1 = (x & 0x0000FF00);
unsigned byte0 = (x & 0x000000FF);
// printf("%x\n\n",byte0);
byte3 = byte3 >> 24;
byte2 = byte2 >> 8;
byte1 = byte1 << 8;
byte0 = byte0 << 24;
return (byte0 + byte1 + byte2 + byte3);
}

// Modul : 02
// Kelompok : -
// Nama File : reversebyte.h
dan bitwise NOT
#ifndef REVERSEBYTE
#define REVERSEBYTE
int reversebyte (int x);
#endif

// Modul : 02
// Kelompok : -
// Nama File : minbyte.c
dan bitwise NOT
#include <stdio.h>
#include "minbyte.h"
int minbyte (int x, int y){

x = (x<<24)>>24;
y = (y<<24)>>24;
y=~y+1;
x=x+y;
x=x&0x000000FF;
return x;
}

// Modul : 02
// Kelompok : -
// Nama File : minbyte.h
dan bitwise NOT
#ifndef MINBYTE
#define MINBYTE
int minbyte (int x, int y);
#endif

// Modul : 02
// Kelompok : -
dan bitwise NOT
#include <stdio.h>
#include "minbyte.h"
int main (void){

int x,y;
printf("Masukkan bilangan pertama (hex angka max 2 angka) : 0x"); scanf ("%x",&x);
printf("Masukkan bilangan kedua (hex angka max 2 angka) : 0x"); scanf ("%x",&y);
printf("Hasil Pengurangan : 0x0%x", minbyte(x,y));
}

// Modul : 02
// Kelompok : -
// Nama File : shiftregister.c
dan bitwise NOT
#include <stdio.h>
#include <stdlib.h>
int global_var =0;
int main (void){
int x;
printf("Masukkan input : 0x"); scanf("%x",&x);
printf("Hasil Shift Register : 0x%.8x", shiftregister(x));
}
int shiftregister (int x){

global_var = (global_var << 5) | x;
return global_var;
}

// Modul : 02
// Percobaan :
// Kelompok : NA
// Nama (NIM) 1 : Praktikan 1
// Nama File : enkripsidekripsi.c
// Deskripsi : Demonstrasi Pointer
#include <stdio.h>
int enkripsi (int angka, int desimal);
int dekripsi (int angka, int desimal);
int main (){
int desimal, pengenkripsi, pendekripsi;
printf("Masukkan bilangan desimal yang akan di enkripsi (9digit) : "); scanf("%d",
&desimal);
printf("Masukkan bilangan desimal untuk input enkripsi :");
scanf("%d",&pengenkripsi);
pengenkripsi = pengenkripsi & 0x000000FF;
printf("\n Hasil enkripsi : %d\n",enkripsi(desimal,pengenkripsi));
printf("Masukkan bilangan desimal yang akan di enkripsi (9digit) : "); scanf("%d",

&desimal);
printf("Masukkan bilangan desimal untuk input enkripsi :");
scanf("%d",&pendekripsi);
pendekripsi = pendekripsi & 0x000000FF;
printf("\n Hasil enkripsi : %d\n",dekripsi(desimal,pendekripsi));
return 0;
}
int enkripsi (int angka, int desimal){

int byte0,byte1,byte2,byte3;
byte0=(angka^desimal) & 0x000000FF;
byte1=(((angka>>8)^desimal)<<8 & 0x0000FF00);
byte2=(((angka>>16)^desimal<<16)&0x00FF0000);
byte3=(((angka>>24)^desimal<<24)&0xFF000000);
return (byte0+byte1+byte2+byte3);
}
int dekripsi (int angka, int desimal){
int byte0,byte1,byte2,byte3;
byte0=(angka^desimal) & 0x000000FF;
byte1=(((angka>>8)^desimal)<<8 & 0x0000FF00);
byte2=(((angka>>16)^desimal<<16)&0x00FF0000);
byte3=(((angka>>24)^desimal<<24)&0xFF000000);
return (byte0+byte1+byte2+byte3);
}

// Modul : 02
// Percobaan :
// Kelompok : NA
// Nama File : printbitbyte.c
#include <stdio.h>
void coba (int* x, int* y, int* z){

//kamus
int a,b,c,d;
a = *x;
b = *y;
c = *z;
d = a+b;
*y=d;
*z=b;
*x=c;
}
int main (void){

return (0);
}

// Modul : 02
// Percobaan :
// Kelompok : NA
#include <stdio.h>
void coba (double* x, double* y, double* z){

//kamus
double a,b,c,d;
a = *x;
b = *y;
c = *z;
d = a+b;
*y=d;
*z=b;
*x=c;
}
int main (void){

return (0);
}

// Modul : 02
// Percobaan :
// Kelompok : NA
#include <stdio.h>
int main (){
int i, length;
char teks[length+1];
printf("Masukkan panjang kata : "); scanf("%d", &length);
printf("Masukkan Kata :\n");
for (i=0;i<(length+1);i++){
scanf("%c", &teks[i]);
}
for (i=(length);i>-1;i--){
printf("%c", teks[i]);
}
return (0);
}

// Modul : 02
// Percobaan :
// Kelompok : NA
#include<stdio.h>
int main (){

int length, banyak_data,kar,i,j;
char nama_orang [100][100],junk,restore;
printf("Masukkan banyak nama : \n"); scanf("%d", &banyak_data);

for(i=0;i<banyak_data;i++){
printf("Masukkan Panjang Karater Kata %d\n", i+1); scanf("%d",&length);
printf("Masukkan Karakternya : \n");
for (j=0;j<(length+1);j++){
scanf("%c",&nama_orang[i][j]);
}
// printf("\n");
}
for (i=0;i<banyak_data;i++){
printf("Nama %d\t:\n",i+1);
for(j=1;j<length+1;j++){
restore = nama_orang[i][j];
printf("%c\n",restore);
}
printf("\n");
}
return 0;
}

// Modul : 02
// Percobaan :
// Kelompok : NA
#include<stdio.h>
int main (){

char *nama[10],input[10][31];
int i,j;
printf("Masukkan Nama kata per kata (max=10): \n");

for(i=0;i<10;i++){
gets(input[i]);
nama[i]=input[i];
if(!strcmp(nama[i],"exit")){
break;
}
}
printf("Output : \n");
for(j=0;j<i;j++){
printf("%s", nama[j]);
}
return 0;
}

// Modul : 02
// Percobaan :
// Kelompok : NA
#include <stdio.h>
struct matrics{
int jb;
int jk;
int** nilai;
};
struct matrics mulmatrics(struct matrics A, struct matrics B){
int i,j,k,l;
struct matrics x;
x.jk=B.jk;
x.jb=A.jb;
x.nilai = (int**)calloc(x.jb,sizeof(int*));
for(i=0;i<x.jb;i++){
x.nilai[i]=(int*)calloc(x.jk,sizeof(int));
}
for(k=0;k<A.jk;k++){
for(i=0;i<A.jb;i++){
l=A.nilai[i][k];
for(j=0;j<x.jk;j++){
x.nilai[i][j] += l*B.nilai[k][j];
}
}
}
return x;
}
int main (void){
struct matrics A,B,C;
int i,j;
printf("Masukkan jumlah Baris matriks A : "); scanf ("%d", &A.jb);

printf("Masukkan jumlah Kolom matriks A : "); scanf ("%d", &A.jk);
A.nilai = malloc(A.jb*sizeof(int*));
for(i=0;i<=A.jb;i++){
A.nilai[i]=malloc(A.jk*sizeof(int));
}
for(i=0;i<=A.jb-1;i++){
for(j=0;j<=A.jk-1;j++){
printf("Masukkan elemen ke %d, %d : ", i+1,j+1);
scanf("%d", &A.nilai[i][j]);
}
}
printf("Masukkan jumlah Baris Matriks B: "); scanf("%d", &B.jb);
printf("Masukkan jumlah kolom Matriks B: "); scanf("%d", &B.jk);
B.nilai = malloc(B.jb*sizeof(int*));
for(i=0;i<=B.jb;i++){
B.nilai[i]=malloc(B.jk*sizeof(int));
}
for(i=0;i<=B.jb-1;i++){
for(j=0;j<=B.jk-1;j++){
printf("Masukkan elemen ke %d, %d : ", i+1,j+1);
scanf("%d", &B.nilai[i][j]);
}
}
if(A.jk = B.jb){
C = mulmatrics(A,B);
printf("\nHasil Perkalian Dua Buah Matriks : \n");
for(i=0;i<=A.jb-1;i++){
for(j=0;j<=C.jk-1;j++){
printf("%d ", C.nilai[i][j]);
}
printf("\n");
}
}
else {
printf("Tidak memenuhi syarat perkalian matriks\n");
}
return 0;
}

// Modul : 02
// Percobaan :
// Kelompok : NA
#ifndef BIT
#define BIT
int bitXOR(int a, int b);
int getbit(int x, int y);
int bitdes(int *z);
#endif

// Modul : 02
// Percobaan :
// Kelompok : NA
#include <stdio.h>
#include <math.h>
#include "biner.h"
int bitXOR (int a, int b){

int result;
result = ~(~(~a&b)&~(a&~b));
return result;
}
int getbit (int x, int y){
return ((x>>y)&1);
}
int bitdes(int *z){
int i, value=0;
for (i=0;i<=6;i++){
value += z[i]*pow(2,i);
}
value -= z[7]*pow(2,7);
return value;
}

// Modul : 02
// Percobaan :
// Kelompok : NA
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "biner.h"
int main (void){

int x,y,i,temp,hasil,add,min,A[8],B[8],C[8],result[8],carry=0;
printf("Masukkan bilangan pertama : \n"); scanf("%d", &x);

printf("Masukkan bilangan kedua : \n"); scanf("%d", &y);
for (i=0;i<8;i++){
A[i]=getbit(x,i);
B[i]=getbit(y,i);
}
for (i=0;i<8;i++){
result[i]=bitXOR(bitXOR(A[i],B[i]),carry);
carry=((A[i]&carry)|(B[i]&carry))|(A[i]&B[i]);
}
printf("Hasil penjumlahan Biner : ");
for (i=0; i<8;i++){
printf("%d",result[i]);
}
add=bitdes(result);
printf("\nHasil Desimal : %d",add);
y=~y+1;
for(i=0;i<8;i++){
C[i]=getbit(y,i);
}
for(i=0;i<8;i++){
result[i]=bitXOR(bitXOR(A[i],C[i]),carry);
carry=((A[i]&carry)|(C[i]&carry))|(A[i]&C[i]);
}
printf("\nHasil Pengurangan Biner : ");

for(i=0;i<8;i++){
printf("%d", result[i]);
}
min=bitdes(result);
printf("\nHasil Desimal : %d", min);
return 0;
}

Pask - 2 - 14S16040 - Basry Sihotang

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Pask - 2 - 14S16040 - Basry Sihotang

Diunggah oleh

Hak Cipta:

Format Tersedia

Modul 2

Pointer, Structure, Array, dan

menyimpan data tersebut dalam memory. Terdapat beberapa

Long 4 Byte -2147483648 –

D. Percobaan IV : Fungsi Membalik Ukuran Byte

1. Source Code Percobaan 1

int bitXOR (int a, int b){

// Praktikum NWS3102 Arsitektur Sistem Komputer

// Praktikum NWS3102 Arsitektur Sistem Komputer

int main (void){

int getbyte (int angka, int ekstraksi){

// Praktikum NWS3102 Arsitektur Sistem Komputer

// Praktikum NWS3102 Arsitektur Sistem Komputer

int main (){

3. Source Code Percobaan 3 :

int bitmask(int highbit, int lowbit);

// Praktikum NWS3102 Arsitektur Sistem Komputer

// Praktikum NWS3102 Arsitektur Sistem Komputer

int main (){

4. Source Code Percobaan 4 :

int main (void){

// Praktikum NWS3102 Arsitektur Sistem Komputer

int reversebyte (int x){

// Praktikum NWS3102 Arsitektur Sistem Komputer

5. Source Code Percobaan 5 :

// Praktikum NWS3102 Arsitektur Sistem Komputer

int minbyte (int x, int y){

// Praktikum NWS3102 Arsitektur Sistem Komputer

// Praktikum NWS3102 Arsitektur Sistem Komputer

int main (void){

6. Source Code Percobaan 6 :

// Praktikum NWS3102 Arsitektur Sistem Komputer

int shiftregister (int x){

7. Source Code Percobaan 7 :

// Praktikum NWS3103 Arsitektur Sistem Komputer

printf("Masukkan bilangan desimal yang akan di enkripsi (9digit) : "); scanf("%d",

int enkripsi (int angka, int desimal){

8. Source Code Percobaan 8 :

// Praktikum NWS3103 Arsitektur Sistem Komputer

void coba (int* x, int* y, int* z){

int main (void){

// Praktikum NWS3103 Arsitektur Sistem Komputer

void coba (double* x, double* y, double* z){

int main (void){

9. Source Code Percobaan 9 :

// Praktikum NWS3103 Arsitektur Sistem Komputer

10. Source Code Percobaan 10 :

// Praktikum NWS3103 Arsitektur Sistem Komputer

int main (){

printf("Masukkan banyak nama : \n"); scanf("%d", &banyak_data);

11. Source Code Percobaan 11 :

// Praktikum NWS3103 Arsitektur Sistem Komputer

int main (){

printf("Masukkan Nama kata per kata (max=10): \n");

12. Source Code Percobaan 12 :

// Praktikum NWS3103 Arsitektur Sistem Komputer

printf("Masukkan jumlah Baris matriks A : "); scanf ("%d", &A.jb);

13. Source Code Percobaan 13 :

// Praktikum NWS3103 Arsitektur Sistem Komputer

// Praktikum NWS3103 Arsitektur Sistem Komputer

int bitXOR (int a, int b){

// Praktikum NWS3103 Arsitektur Sistem Komputer