MANAJEMEN MEMORI

Memory manager :
Salah satu bagian sistem operasi yang mempengaruhi dalam menentukan proses mana yang
diletakkan pada antrian.

Jenis Memori - Memori

Kerja
• ROM/PROM/EPROM/EEPROM
• RAM
• Cache memory
- Memori Dukung
Floppy, harddisk, CD, dll.

Alamat Memori
– Alamat memori mutlak (alamat fisik)
– Alamat memori relatif (alamat logika)
– Hubungan antara alamat multak dan alamat relatif
– Jenis memori dan alamat memori

Isi Memori
– Sistem bahasa penataolahan
– Sistem Utilitas
– Inti Sistem Operasi
– Sistem Operasi
– Pengendali alat (device drivers) – File pemakai

Fungsi manajemen memori :

• Mengelola informasi yang dipakai dan tidak dipakai.
• Mengalokasikan memori ke proses yang memerlukan.
• Mendealokasikan memori dari proses telah selesai.
• Mengelola swapping atau paging antara memori utama dan disk.

MANAJEMEN MEMORI BERDASARKAN

KEBERADAAN SWAPPING ATAU PAGING
Terbagi dua yaitu :
1. Manajemen tanpa swapping atau paging
2. Manajemen dengan swapping atau paging

MEMORI TANPA SWAPPING OR PAGING

¾ Yaitu manajemen memori tanpa pemindahan citra proses antara memori utama dan disk selama
eksekusi.
¾ Terdiri dari :
 Monoprogramming
Ciri-ciri :
• Hanya satu proses pada satu saat
• Hanya satu proses menggunakan semua memori
• Pemakai memuatkan program ke seluruh memori dari disk atau tape
• Program mengambil kendali seluruh mesin
 Sistem Operasi Sistem Operasi di Sistem Operasi di
di RAM ROM RAM

Program Program Program

Pemakai di Pemakai di Pemakai di
RAM RAM RAM

Memori Tidak Memori Tidak

Dipakai Dipakai
Memori Tidak
Dipakai Device Driver
di ROMD

=RAM
=ROM
Contoh : IBM PC menggunakan cara ketiga di mana device driver ROM
ditempatkan pada blok 8K tertinggi dari address space 1M. Program pada ROM
disebut BIOS (Basic Input Output System).

Gambar 1. Tiga Cara Organisasi Memori Satu Proses Tunggal

Multiprogramming Dengan Pemartisian Statis Terbagi dua :
1. Pemartisian menjadi partisi-partisi berukuran sama, yaitu ukuran semua partisi
memori adalah sama
2. Pemartisian menjadi partisi-partisi berukuran berbeda, yaitu ukuran semua partisi
memori adalah berbeda.

Strategi Penempatan Program Ke Partisi

¾ Satu Antrian Tunggal Untuk Semua Partisi

Keuntungan : Lebih fleksibel serta implementasi dan operasi lebih minimal karena
hanya mengelola satu antrian.
Kelemahan : Proses dapat ditempatkan di partisi yang banyak diboroskan, yaitu proses kecil
ditempatkan di partisi sangat besar.
 Partisi 1 50 Kbyte
Partisi 2
75 Kbyte
Partisi 3 100 Kbyte

200 Kbyte
Partisi 4

150 Kbyte
Partisi 5
Sistem Operasi

Gambar 2. Multiprogrammning dengan Pemartisian Tetap dengan Satu Antrian

Satu Antrian Untuk Tiap Partisi (banyak antrian Untuk

Seluruh Partisi)
Keuntungan : Meminimalkan pemborosan memori Kelemahan : Dapat terjadi antrian
panjang di suatu
partisi sementara antrian partisi - partisi lain kosong

Partisi 1 50 K byte
Partisi 2 75 K byte

Partisi 3
100Kbyte

200Kbyte
Partisi 4

150Kbyte
Partisi 5
100Kbyte

Gambar 3. Multiprogrammning dengan Pemartisian

Tetap dengan Banyak Antrian
(Bambang Hariyanto, hlm. 158)
MULTIPROGRAMMING DENGAN SWAPPING
Swapping : pemindahan proses dari memori utama ke disk dan kembali lagi.

1. Multiprogramming dengan Pemartisisan Dinamis

Jumlah , lokasi dan ukuran proses di memori dapat beragam sepanjang waktu secara dinamis.
Kelemahan:
- Dapat terjadi lubang-lubang kecil memori di antara partisipartisi yang dipakai.
- Merumitkan alokasi dan dealokasi memori

Solusi:
Lubang-lubang kecil di antara blok-blok memori yang digunakan dapat diatasi dengan
pemadatan memori yaitu menggabungkan semua lubang kecil menjadi satu lubang besar
dengan memindahkan semua proses agar saling
berdekatan.

MMMemori Untuk MMMemori Untuk

Sistem Operasi Sistem Operasi
Proses 0 Proses 0

Bebas Proses 2

Proses 2 Proses 4
Bebas
Proses 6
Proses 4

Bebas
Bebas

Proses 6
Gambar 4. Lubang-lubang Memori dan Pemadatan Memori
(Bambang Hariyanto, hlm. 165)

2. Pencatatan Pemakaian memori

¾ Pencatatan memakai peta bit (Bit Map)
¾ Pencatatan memakai linked list

Pencatatan memakai peta bit

- Nilai 0 pada peta bit berarti unit masih bebas
- Nilai satu berarti unit digunakan
A 7 B 15 C
0

0 1 2 3 4 5 6 7
1 1 1 1 1 0 0 0
1 1 1 1 1 1 1 1
1 1 0 0 1 1 1 1
. . . . . . . .

Gambar 5. Peta Bit untuk Pengelolaan Pemakaian Memori

(Bambang Hariyanto, hlm. 166)

Pencatatan memakai Linked List

• P= Proses, H=Hole(lubang)

A 7 B 15 C
0

P 0 5 H 5 3 P 8 8 P 16 2

H 18 2 P 20 4

Hole Panjang 2 Proses

Start
Di 18

Gambar 6. Pengelolaan Pemakaian dengan Linked List

(Bambang Hariyanto, hlm. 167)
3. Strategi Alokasi Memori
¾ First fit algorithm : memory manager men-scan list untuk menemukan hole yg cukup untuk
menampung proses yg baru. Proses akan menempati hole pertama yg ditemuinya yg cukup
untuk dirinya.
 Jmlh
Hole
Semula 1
1024
Permintaan 70 Kb A 128 256 512 3
Permintaan 35 Kb A B 64 256 512
3
Permintaan 80 Kb A B 64 C 128 512 3
A didealokasi 128 B 64 C 128 512 4
Permintaan 60 Kb 4
128 D C 128 512
B didealokasi 128 D C 128 512 4
D didealokasi 256 C 128 512 3
C didealokasi 1024
1

Gambar 7. Pengelolaan Memori dengan Sistem Buddy

¾ Next fit algorithm : sama dengan first fit, tetapi pencarian hole dimulai dari hole ditemuinya
dari scan sebelumnya.
¾ Best fit algorithm : dicari hole yang akan menghasilkan sisa paling sedikit setelah dimasuki
proses.
¾ Worst fit algorithm : kebalikan dari best fit.
¾ Quick fit algorithm : mengelompokkan hole-hole dan membuat listnya sendiri. Misalnya, ada
list untuk hole 4K, satu list untuk 8K, dst.

Sistem Buddy
Memori di susun dalm senari blok-blok bebas berukuran 1,2,4,8,16 byte dst, sampai kapasitas
memori.
(Tanenbaum, Bab 3, hlm 86)

Dari berbagai cara alokasi tsb. Di atas, sebuah hole yg ditempati proses akan terbagi menjadi bagian
yang dipakai proses dan memori yang tidak terpakai (fragmen).
Timbulnya memori yang tidak terpakai disebut fragmentasi. Ada dua macam fragmen :
• Internal : sisa hole yang tidak terpakai setelah terisi proses.
• Eksternal : hole yang secara utuh terlalu kecil untuk dipakai oleh proses manapun.
Alokasi Ruang Swap pada Disk
(Penempatan proses pada disk setelah di-swap-out dari memori) - Ruang disk tempat swap
dialokasikan begitu diperlukan - Ruang disk tempat swap dialokasikan lebih dahulu.

Algoritma untuk pengaturan ruang swap pada disk sama dengan untuk memori utama.
Perbedaannya adalah ruang pada disk harus dialokasikan sebagai kelipatan bilangan bulat dari
disk block.
Dan ini implementasi dengan bahasa C

#include<stdio.h>
#include<stdlib.h>

void display(int ,int [10]);

void firstfit(int ,int [10],int [10],int);
void nextfit(int ,int [10],int [10],int);
void bestfit(int ,int [10],int [10],int);
void worstfit(int,int [10],int [10],int);

int main()
{
int npr,nh=0,i,j,k,pr[10],hol[10],ch,temp[10];
do{
printf("\n\n----------MENU------------\n1.INPUT"
"\n2.FIRST-FIT \n3.BEST FIT\n4.NEXT FIT"
"\n5.WORST FIT\n6.KELUAR\n\nMASUKAN PILIHAN : ");
scanf("%d",&ch);
for(i=0;i<nh;i++)temp[i]=hol[i];
switch(ch)
{
case 1:
printf("\n Masukan jumlah pemrosesan: ");
scanf("%d",&npr);
printf("\n Masukan jumlah Lubang: ");
scanf("%d",&nh);
for(i=0;i<npr;i++)
{
printf("\n\tProses ke - %d:",i+1);
scanf("%d",&pr[i]);
}
for(i=0;i<nh;i++)
{
printf("\n\tLubang ke - %d:",i+1);
scanf("%d",&hol[i]);
temp[i]=hol[i];
}
break;
case 2:
firstfit(npr,temp,pr,nh);
break;
case 3: bestfit(npr,temp,pr,nh);
break;
case 4:nextfit(npr,temp,pr,nh);
break;
case 5:worstfit(npr,temp,pr,nh);
break;
case 6:exit (0);//break;
default:printf("\nPilihan Salah......!");
}
}while(ch!=6);
return 0;
}
//First Fit
void firstfit(int npr,int hol[10],int pr[10],int nh)
{
int i,j,k,flag=0;
for(i=0;i<npr;i++)
{
flag=0;
for(j=0;j<nh;j++)
{
if(pr[i]<hol[j])
{
hol[j]=hol[j]-pr[i];printf("\nMemory dialokasikan untuk Proses %d :(%d)",i+1,pr[i]);
flag=1;break;
}
else if(pr[i]==hol[j])
{
flag=1;printf("\nMemory dialokasikan untuk Proses %d :(%d)",i+1,pr[i]);
for(k=j;k<nh-1;k++)
{
hol[k]=hol[k+1];
} nh--;
break;
}
}
if(flag==0)
{printf("\n Lubang (Hole) tidak ditemukan.....");
break;}
display(nh,hol);
}
}

//Best fit
void bestfit(int npr,int hol[10],int pr[10],int nh){
int i,j,k,min,flag;
for(i=0;i<npr;i++)
{
flag=0;
for(j=0;j<nh;j++)
{
if(pr[i]<=hol[j])
{
flag=1; min=j;
for(k=j;k<nh;k++)
{
if((hol[min]>hol[k])&&(pr[i]<=hol[k]))min=k;

}
if(pr[i]<hol[min])
{printf("\nMemory dialokasikan untuk Proses %d :(%d)",i+1,pr[i]);
hol[min]=hol[min]-pr[i];
break;
}
else if(pr[i]==hol[min])
{printf("\nMemory dialokasikan untuk Proses %d :(%d)",i+1,pr[i]);
for(k=min;k<nh-1;k++)
 hol[k]=hol[k+1];
nh--;
break;
}
}
}
if(flag==0)
{printf("\n Lubang (Hole) tidak ditemukan.....");
break;}
display(nh,hol);
}
}

//Next Fit
void nextfit(int npr,int hol[10],int pr[10],int nh){
int i,j=0,k,flag=0;
for(i=0;i<npr;i++)
{
flag=0;
for(;j<nh;)
{
if(pr[i]<hol[j])
{
hol[j]=hol[j]-pr[i];
flag=1;printf("\nMemory dialokasikan untuk Proses %d :(%d)",i+1,pr[i]);
break;
}
else if(pr[i]==hol[j])
{
flag=1;printf("\nMemory dialokasikan untuk Proses %d :(%d)",i+1,pr[i]);
for(k=j;k<nh-1;k++)
hol[k]=hol[k+1];
nh--;
break;
}
j=(j+1)%nh;

}
if(flag==0)
{printf("\n Lubang (Hole) tidak ditemukan.....");
break;}
display(nh,hol);
}
}

//worst fit
void worstfit(int npr,int hol[10],int pr[10],int nh)
{
int i,j,k,max,flag;
for(i=0;i<npr;i++)
{
flag=0;
for(j=0;j<nh;j++)
{
if(pr[i]<=hol[j])
 {
printf("\nMemory dialokasikan untuk Proses %d :(%d)",i+1,pr[i]);
flag=1; max=j;
for(k=j;k<nh;k++)
{
if((hol[max]<hol[k])&&(pr[i]<=hol[k]))max=k;
}
if(pr[i]<hol[max])
{

hol[max]=hol[max]-pr[i];
break;
}
else if(pr[i]==hol[max])
{

for(k=max;k<nh-1;k++)
hol[k]=hol[k+1];
nh--;
break;
}
}
}
if(flag==0)
{printf("\n Lubang (Hole) tidak ditemukan.....");
break;}
display(nh,hol);
}
}
void display(int nh,int hol[10])
{
printf("\nLubang:");int i=0;
for(i=0;i<nh;i++){printf("%d\t",hol[i]);}
}