TUGAS III

Virtual Memory pada - SolarisDosen: Dr.-Ing. M.Reza Pulungan, S.Si, M.Sc

Oleh : Ervin Kusuma Dewi Khadijah Lelly Hidayah Anggraini Ika Candradewi 323335 325316 309045 322924

PROGRAM ILMU KOMPUTER FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM UNIVERSITAS GADJAH MADA YOGYAKARTA 2011

i

DAFTAR ISIDAFTAR ISI ........................................................................................................................................................... i DAFTAR GAMBAR ............................................................................................................................................ ii DAFTAR TABEL ................................................................................................................................................iii BAB I PENDAHULUAN ................................................................................................................................... 1 BAB II VIRTUAL MEMORY ........................................................................................................................... 2 2.1 Virtual Memory pada Solaris .................................................................................................... 2 Fungsi Virtual Memory ...................................................................................................... 2 Implementasi Virtual Memory pada Solaris ............................................................. 2 Virtual Address Space ......................................................................................................... 4

2.1.1 2.1.2 2.1.3 2.2

Memori Segment .......................................................................................................................... 15 Copy on Write ...................................................................................................................... 20 Page Protection and Advice............................................................................................ 21

2.2.1 2.2.2 2.3

Swap Layer ..................................................................................................................................... 21 Swap Allocation .................................................................................................................. 22 Impelementasi Swapfs .................................................................................................... 23

2.3.1 2.3.2 2.4

Global Page Manajemen ........................................................................................................... 23 Pages ........................................................................................................................................ 23 Page Hash List ..................................................................................................................... 24 MMU-Specific Page Structures .................................................................................... 26 Physical Page list ................................................................................................................ 27 Page-Level Interface ......................................................................................................... 27 Page Size................................................................................................................................. 28 Pageout Process .................................................................................................................. 28 Pageout Scanner ................................................................................................................. 29 Pageout Scanner Parameter ......................................................................................... 30

3.4.1 3.4.2 3.4.3 3.4.4 3.4.5 3.4.6 3.4.7 3.4.8 3.4.9 2.5

Memory Scheduler ..................................................................................................................... 32

BAB III KESIMPULAN .................................................................................................................................. 34 DAFTAR PUSTAKA ........................................................................................................................................ 35

i

DAFTAR GAMBAR

Gambar 2.1 Layer Virtual Memory pada Solaris ................................................................3 Gambar 2.2 Virtual address space Sebuah Proses ............................................................4 Gambar 2.3 Address Space Proses pada SPARC ...............................................................6 Gambar 2.4 Intel x86 Process Address Space ...................................................................6 Gambar 2.5 Address Space .............................................................................................10 Gambar 2.6 Contoh Virtual address space Page Fault ...................................................14 Gambar 2.7 Segment Interface ......................................................................................16 Gambar 2.8 seg_vn Segment driver relationship ..........................................................19 Gambar 2.9 Shared Mapped Files ..................................................................................20 Gambar 2.10 anon slot inisialisasi pada virtual swap sebelum page-out ....................23 Gambar 2.11 Struktur page ...........................................................................................24 Gambar 2.12 Pengalokasian page dengan Vnode/offset identity ................................25 Gambar 2.13 Contoh Struktur Page Mesin-spesifik : sun4u ........................................26 Gambar 2.14 Contiguous Physical Memory Segments .................................................27 Gambar 2.15 Pageout Scanner ......................................................................................29 Gambar 2.16 Parameter Pageout Scanner ....................................................................30

ii

DAFTAR TABEL

Tabel 2.1 Ukuran Maximum pada Heap Solaris ...............................................................8 Tabel 2.2 Daftar Fungsi Segmen ....................................................................................10 Tabel 2.3 Solaris Segment Driver ....................................................................................17 Tabel 2.4 mmap Shared Mapped File Flags ...................................................................21 Tabel 2.5 Alokasi swap space .........................................................................................22 Tabel 2.6 Page Size pada different Sun Platform ...........................................................28 Tabel 2.7 Parameter Pageout .........................................................................................31

iii

BAB I PENDAHULUAN

Solaris merupakan Operating System (system operasi) dikembangkan oleh Sun Microsystem yang menggantikan SunOS pada tahun 1993. Solaris dikenal dengan skalabilitasnya yang dimilikinya terutama pada system komputer bebasis SPARC. Solaris sangat cocok untuk multiprocessing simetri dan memiliki fitur-fitur inovatif yang dibawanya seperti DTrace, ZFS (Zettabyte File System) dan Time Slider. (Wikipedia, 2011) Solaris dalam sebagai perangkat lunak yang dikembangkan bebasis kode yang tertutup, artinya tidak dapat dikembangkan selain perusahaan tersebut. kemudian Sun Microsystem memulai membuka basis kode dibawah lisensi CDDL serta mendirikan proyek OpenSolaris. Melalui OpenSolaris Sun ingin membuat sebuah komunitas pengembang dan pengguna system operasi tersebut. Dalam system Operasi Solaris banyak proses-proses di dalamnya. Program yang sedang barjalan pada system operasi memiliki ruang alamat (address space) terpoteksi dan satu atau lebih yang mengeksekusi kode. Kode dan struktur data yang digunakan solaris adalah menejemen virtual memory. Pada pembahasan kali ini akan dijelaskan secara spesifik tentang Virtual Memory pada Sistem Operasi Solaris yang dikembangkan dengan menggunakan framework object-oriented yang diikuti dengan teknologi baru filesystem untuk memudahkan intergrasi Operating System (Sistem Operasi), selain itu Solaris memiliki arsitektur vnode yang merupakan deskripsi Virtual Memory yang di adopsi dari SunOs yang membentuk inti dari UNIX AT&T V keluaran 4.0. (Sun Microsystem, 1998)

1

BAB II VIRTUAL MEMORY SOLARIS

Salah satu objek dari Virtual Memory (VM) diikuti dengan memory yang lebih besar yaitu physical memory dengan proses untuk memori yang lebih besar dari primary storage (RAM) dan secondary storage (Disk) namun lebih lambat tetapi lebih besar storagenya. Dapat dilihat bahwa virtual sebagai memori penyimpanan space address yang merupakan representasi dari aplikasi. Kerja dari Virtual Memory adalah menjaga frekwensi partisi dari memori pada kecepatan Primary Storage. 2.1 Virtual Memory pada Solaris 2.1.1 Fungsi Virtual Memory

Penyimpanan di RAM, Virtual Memory memerlukan memori kosong di RAM guna memindahkan penggunaan memori yang jarang mendapatkan backing store.Virtual Memory juga memerlukan multiple user yang mana program biner dan data aplikasi dibagi antar user dan dishare dimanajemen memori yang tak membutuhkan contohnya yaitu mengeksekusi aplikasi. Menurut (Sun Microsystem, 1998) fungsi performa dari manajemen Virtual Memory adalah sebagai berikut : 1. Virtual : dengan mapping physical untuk memory. 2. Swaping : memori antara penyimpanan primer dan sekunder untuk optimasi performa. 3. Requirement : untuk share gambar antara user dan proses. 2.1.2 Implementasi Virtual Memory pada Solaris

SunOS versi 3 berdasarkan BSD memory system, yang tidak modular dan susah berpindah memory untuk platform yang berbeda. Maka dari itu Virtual memory system didesain kembali dengan memory yang diterapkan pada SunOS 4.0. pada SunOS Virtual Memory dibangung dengan mengharapkan : Menggunakan object-oriented memory manajemen framework. Support untuk share dan private memory (copy-on-write) Page-based Virtual Memory Manajemen 2

Virtual Memory merupakan tujuan desain dari Solaris yang menyediakan open framework yang support dengan banyak objek memori yang berbeda. Objek yang penting dari memory adalah segemen, vnode dan pages. Contoh dari implementasi pemindahan objek adalah menurut (Jim Mauro dan Richard McDougall, 2000) : Physical Memory memanggil potongan pages. Vnode sebagai file objek baru. File system sebagai hirarki dari vnode Proses address space sebagai segement untuk memetakan vnode Kenel address space sebagai segement untuk memetakan vnode Memetakan hardware sebagai frame buffer untuk segemen dari memetakan page hardware. Pyisical memory manajemen mengerjakan MMU hardware dan spesifik hardware untuk menerjemahkan dari lapisan Hardware Address Translation (HAT).Tiap tipe dari memory manajemen mempunyai spesifik implementasi HAT.Sehingga kita dapat menyalin keadaan machine-independent memory manajemen dari spesifik komponen hardware untuk memperkecil jumlah kode platform mejadi tiap-tiap platform baru.

Gambar 2.1 Layer Virtual Memory pada Solaris

3

2.1.3

Virtual Address Space

Virtual address space dari sebuah proses adalah daerah alamat memori yang diberikan ke proses tersebut. Sejumlah alamat dipetakan ke memori fisik dan sebagian lagi tidak. Kerangka virtual address space dari sebuah proses diciptakan oleh kernel pada saat system call fork() menciptakan proses tersebut. Virtual address layout di dalam sebuah proses dibuat oleh dynamic linker dan bervariasi pada platform perangkat keras yang berbeda. Virtual address space tersusun dari serangkaian segmen memori. Setiap proses paling tidak memiliki empat segmen berikut: 1) Executable text Instruksi executable dalam binary berada dalam text segment. Text segment dipetakan dari disk binary dan dipetakan read-only dengan permission execute. 2) Executable data Inisiasi variabel dalam executable berada dalam data segment. Data segment dipetakan dari disk binary dan dipetakan read/write/private. Pemetaan private memastikan bahwa perubahan ke memory saat pemetaan tidak direleksikan ke file atau proses lain yang memetakan executable yang sama. 3) Heap space, memori dialokasikan oleh malloc(), dialokasikan dari anonymous memory dan dipetakan read/write. 4) Process stack Stack dialokasikan dari anonymous memory dan dipetakan read/write.

Gambar 2.2 Virtual address space Sebuah Proses

4

Gambar di atas mengilustrasikan virtual address space dari sebuah proses, yaitu /sbin/sh. Executable proses dipetakan di dekat alamat bagian bawah, diikuti heap di atasnya, stack berada paling atas, dan terdapat sebuah hole di antara heap dan stack. Heap dapat tumbuh ke atas saat ada alokasi memori tambahan melalui malloc(), dan stack tumbuh ke bawah saat ada frame yang ditempatkan ke stack. 2.1.3.1 Sharing of Executable and Library

Kernel solaris mendukung sharing memori, file, library, dan executable. Contohnya, kernel solaris berbagi library melalui pemetaan file library secara dinamis ke dalam address space selama startup program. Library dipetakan ke dalam address space antara stack dan heap, pada tempat yang berbeda dalam platform yang berbeda. Ketika file library dipetakan ke dalam address space sebuah proses, file tersebut dapat dipetakan secara shared sehingga semua proses berbagi page memori fisik yang sama. Executable text dan data juga di-share dengan cara yang sama, melalui pemetaan sederhana executable file yang sama ke dalam setiap address space. 2.1.3.2 SPARC Address space

Address space proses pada sistem SPARC bervariasi di antara platform SPARC tergantung pada MMU pada platform tersebut. SPARC memiliki 3 address space layout yang berbeda: 1) SPARC V7 mengkombinasikan kernel dan process address space 32-bit, ditemukan pada mesin sun4c, sun4d, dan sun4m . 2) SPARC V9 32-bit memisahkan kernel dan process address space model, ditemukan pada mesin sun4u. 3) SPARC V9 64-bit memisahkan kernel dan process address space model, ditemukan pada mesin sun4u.

5

Gambar 2.3 Address Space Proses pada SPARC Pada semua platform SPARC, bagian bawah virtual address space tidak dipetakan. Null pointer reference akan mengakibatkan segmentation fault, tidak mengembalikan isi apapun pada bagian bawah address space. 2.1.3.3 Intel Address Space Layout

Address space pada Intel x86, seperti SPARC V7 32-bit shared process/kernel address space, berbagi address space yang sama untuk user dan kernel. Perbedaan utama dengan Intel address space adalah stack dipetakan di bawah executable binary dan tumbuh ke bawah sampai bagian paling bawah. Intel address space ditunjukkan pada Gambar berikut.

Gambar 2.4 Intel x86 Process Address Space

6

2.1.3.4

Alokasi Memori ke Proses

Virtual memory sebuah proses untuk struktur data user dialokasikan dari heap segment, yang berada di atas executable data segment. Heap mengecil dan kemudian tumbuh sebagaimana virtual memory dialokasikan. Heap tumbuh dalam satuan page dan secara sederhana merupakan daerah virtual memory yang luas dan tersedia untuk reading dan writing. General-purpose memory allocator mengatur dareah heap, sehingga sembarang ukuran objek memori dapat dialokasikan dan dibebaskan. Generalpurpose memory allocator diimplementasikan dengan malloc() dan library call yang berhubungan. Sebuah proses menumbuhkan ruang heap-nya dengan melakukan system call

sbrk(). sbrk() menumbuhkan heap segment sesuai jumlah yang diminta setiap kalidipanggil. Program user tidak perlu memanggil sbrk() secara langsung karena

malloc() memanggil sbrk() saat memerlukan ruang lebih untuk alokasi. System call sbrk() ditunjukkan seperti berikut: void *sbrk(intptr_t incr);Heap segment adalah virtual memori, sehingga permintaan memory dengan

malloc() dan sbrk() tidak mengalokasikan memori

fisik,

tetapi hanya

mengalokasikan virtual address space. Hanya saat reference pertama dibuat ke sebuah page di dalam alokasi virtual memory yang dialokasikan ke memori fisik. Sistem memori secara transparan menerima ini sebagai alokasi zero fill on demand karena sebuah page fault terjadi saat pertama kali sebuah page direferensi di dalam heap, kemudian segment driver mengenali akses memori pertama dan menciptakan sebuah page pada lokasi tersebut. Page memori dialokasikan ke heap proses melalui zero-fill-on-demand dan kemudian berada di heap segment hingga proses ada atau hingga page tersebut diambil oleh page scanner. Pemanggilan fungsi free() ke memory allocator tidak mengembalikan memori fisik ke free memory pool. Free() hanya menandai dareah di dalam ruang heap menjadi free untuk penggunaan berikutnya. Heap dapat tumbuh hingga berbenturan dengan ruang memori yang ditempati oleh shared library. Ukuran maksimal heap tergantung pada platform virtual memory 7

layout dan berbeda pada tiap platform. Pada platform 64-bit proses dapat mengeksekusi dalam modus 32-bit atau 64-bit. Ukuran heap dapat lebih besar pada proses yang mengeksekusi dalam modus 64-bit. Tabel berikut menunjukkan ukuran maksimum heap dan requirement sistem operasi yang mempengaruhi ukuran maksimum tersebut. Tabel 2.1 Ukuran Maximum pada Heap Solaris

Versi SolarisSolaris 2.5 Soalris 2.5.1

Ukuran Maksimal heap2 Gbytes 2 Gbytes -

Keterangan

Solaris 2.5.1 dengan patch 3,75 Gbytes 103640 atau lebih

Perlu menjadi root untuk menaikkan limit di atas 2 GB dengan unlimit(1M)

Solaris 2.5.1 dengan patch 3,75 Gbytes 103640-23 atau lebih Solaris 2.6 3,75 Gbytes

Tidak perlu menjadi root untuk menaikkan limit. Tidak perlu menaikkan 2GB dengan unlimit(1M)

Solaris 2.7 32 bit mode

3,75 Gbytes 3.90 Gbytes

(bukan platform sun-4u) (platform sun4u) pada Unlimited secara virtual

Solaris 2.7 64 bit mode

16

Tbytes

UltraSPARC-I dan II

2.1.3.5

Stack

Stack proses dipetakan ke dalam address space dengan sebuah alokasi awal dan kemudian tumbuh ke bawah. Stack, seperti heap, tumbuh sesuai permintaan, tetapi tidak ada library yang menumbuhkan stack, sebuah mekanisme lain yang memacu pertumbuhan ini.

8

Pada mulanya, sebuah page tunggal dialokasikan untuk stack, dan sebagaimana proses mengeksekusi dan memanggil fungsi-fungsi, proses mem-push program counter, argument, dan variabel local ke dalam stack. Ketika stack tumbuh lebih besar dari satu page, proses mengakibatkan sebuah page fault, dan kernel mencatat bahwa ini adalah sebuah stack segment page fault dan menumbuhkan stack segmen. 2.1.3.6 Manajemen Address Space

Kernel Solaris diimplementasikan dengan sebuah central address subsystem management. Modul address space adalah sebuah wrapper di sekitar segment driver, sehingga subsistem tidak perlu mengetahui segment driver apa yang digunakan untuk daerah memori. Address space objek ditunjukkan pada Gambar dihubungkan dari

address space proses dan berisi pointer ke segmen yang terdapat address space. Address space subsystem mengelola beberapa fungsi berikut:

Duplikasi address space, untuk fork() Destruksi address space, untuk exit() Penciptaan segmen baru di dalam address space Penghapusan segmen dari address space Pengaturan dan manajemen proteksi page untuk sebuah address space Page fault routing untuk sebuah address space Page locking dan page advice untuk sebuah address space Manajemen watchpoint untuk sebuah address space Address space subsystem terdiri atas serangkaian fungsi yang dikelompokkan

untuk melakukan fungsi-fungsi di atas. Walaupun subsistem memiliki banyak entry point, implementasinya cukup sederhana karena kebanyakan fungsi secara sederhana hanya mencari segmen mana yang operasi perlu untuk mengoperasikannya dan kemudian mengarahkan request ke segment driver yang sesuai. Sebuah panggilan ke fungsi as_alloc() menciptakan sebuah address space, tetapi as_alloc() dipanggil hanya sekali saat sistem melakukan booting dan init process diciptakan. Setalah init process diciptakan, semua address space diciptakan melalui duplikasi address space dari init process dengan fork(). System call fork() memanggil fungsi as_dup() untuk menduplikasi address space dari current process 9

saat menciptakan sebuah proses baru, dan keseluruhan konfigurasi address space, termasuk stack dan heap, direplikasi pada saat ini.

Gambar 2.5 Address Space Di bawah ini merupakan daftar fungsi segmen dari solaris. Tabel 2.2 Daftar Fungsi Segmen

Method As_addseg()

DescriptionMenciptakan sebuah segmen baru dan menghubungkannya ke address space.

As_alloc()

Menciptakan sebuah address space object baru (hanya dipanggil dari kernel untuk init process).

As_clearwatch() As_ctl()

Menghapus semua watchpoint untuk address space. Mengirimkan memory advice ke sebuah address range untuk address space.

10

Method As_dup() As_exec()

DescriptionMenduplikasi keseluruhan address space. Kode khusus untuk exec(), untuk memindahkan segmen stack dari tempat sementaranya di dalam alamat yang lama ke tempat yang benar dalam address space yang baru.

As_fault() As_findseg()

Menangani sebuah page fault di dalam address space. Menemukan segment yang berisi virtual address yang tersedia.

As_free()

Menghancurkan address space object; dipanggil oleh

exit(). As_gap()Menemukan sebuah lubang dengan ukuran tertentu di dalamnya.

As_get_memid()

Memanggil segment driver yang berisi address yang tersedia untuk menemukan ID unik untuk segmen ini.

As_getprot()

Mendapatkan pengaturan proteksi terkini untuk address yang tersedia.

As_map() As_memory()

Memetakan sebuah file ke address space. Mengembalikan daerah selanjutnya di dalam [base, base

+ len] yang didasarkan dengan memori nyata. As_pagelock()Mengunci sebuah page di dalam address space dengan memanggil fungsi segment page lock.

As_pagereclaim()

Mengambil sebuah page dari daftar yang free untuk memenuhi alamat.

As_pageunlock() As-

Meng-unlock sebuah halaman di dalam address space. Membangun semua thread yang menunggu pada address

11

Method

Description

rangebroadcasta() space condition variable. As_rangeunlock() As_rangewait()Meng-unlock page untuk address range yang terpenuhi. Menunggu virtual address agar tersedia dalam address space tertentu. AS_CLAIMGAP harus dibawa oleh pemanggil dan diisi kembali sebelum dikembalikan ke pemanggil.

As_setas() As_setprot()

Menemukan sebuah segmen yang berisi address yang ada. Mengatur virtual mapping untuk interval dari [addr: addr

+ size) dalam address space as untuk memiliki proteksitertentu.

As_setwatch()

Mengatur watchpoint untuk address. Pada sistem yang tidak mendukung watchpoint, fungsi ini tidak bekerja.

As_swapout()

Men-swap page yang berhubungan dengan address space ke secondary storage, mengembalikan jumlah bit yang baru saja di-swap.

As_unmap()

Tidak memetakan sebuah segment dari address space.

2.1.3.7

Virtual Memory Protection Mode

Solaris memecah setiap proses ke dalam sejumlah segmen sehingga, bagian dari address space dapat diperlakukan secara berbeda. Contohnya, kernel memetakan potongan kode mesin dari executable binary ke dalam proses sebagai read-only untuk mencegah proses memodifikasi instruksi kode mesinnya. Virtual memory subsystem melakukan ini dengan memanfaatkan kemampuan proteksi virtual memory dari perangkat keras MMU. Solaris mengandalkan MMU yang memiliki mode proteksi sebagai berikut:

Read, pemetaan diijinkan untuk dibaca. Write, pemetaan diijinkan untuk ditulis. 12

Executable, pemetaan diijinkan untuk memiliki kode mesin yang dieksekusi di dalam daerah alamatnya. Implementasi mode proteksi tersebut dilakukan di dalam segmen dan layer HAT. 2.1.3.8 Page Fault dalam Address Space

Sistem virtual memori Solaris menggunakan kemampuan manajemen memori dari perangkat keras MMU. MMU men-generate exception memberi tahu ke sistem operasi ketika sebuah akses ke memori tidak dapat berlanjut tanpa intervensi kernel, dengan menginterupsi proses yang sedang dieksekusi dengan sebuah trap, kemudian memanggil bagian kode manajemen memori yang bersesuaian. 3 tipe exception perangkat keras yang berhubungan dengan memori dapat terjadi, yaitu major page fault, minor page fault, dan protection fault. 1. Major Page Fault Major page fault terjadi ketika sebuah usaha untuk mengakses lokasi virtual memory yang dipetakan oleh segmen tidak memiliki sebuah page fisik di memori yang dipetakan kepadanya dan page tersebut tidak ada di memori fisik. Saat sistem memori menempatkan page yang sebenarnya di belakang alamat memory, proses dapat melanjutkan eksekusi secara normal. Jika sebuah referensi dibuat ke alamat memori yang tidak dipetakan oleh segmen apapun, maka sebuah segmentation violation signal (SIG_SEGV) dikirimkan ke proses. Sinyal dikirimkan sebagai hasil dari exception perangkat keras yang ditangkap oleh prosesor dan diterjemahkan ke sebuah sinyal oleh address space layer. 2. Minor Page Fault Minor page fault terjadi saat sebuah usaha untuk mengakses lokasi virtual memory yang berada di dalam sebuah segment dan page tersebut berada di dalam memori fisik, tetapi tidak ada translasi MMU saat ini yang dibangun dari page fisik ke address space yang mengakibatkan fault. 3. Protection Fault Page protection fault terjadi saat sebuah program berusaha mengakses sebuah alamat memori dalam cara yang melanggar proteksi akses yang dikonfigurasi sebelumnya untuk sebuah segmen memori. Mode proteksi dapat mengaktifkan akses read, write, atau execute. Contohnya, text dari sebuah binary dipetakan read13

only, dan jika user berusaha untuk menulis ke alamat memori di dalam segmen tersebut, akan menyebabkan sebuah memory protection fault. Memory protection fault juga diinisiasi oleh perangkat keras MMU sebagai sebuah trap yang kemudian ditangani oleh segmen page fault yang menangani rutin. Gambar berikut menunjukkan hubungan antara sebuah virtual address space, segmen-segmennya, dan perangkat keras MMU.

Gambar 2.6 Contoh Virtual address space Page Fault Gambar tersebut menunjukkan apa yang terjadi saat sebuah proses mengakses lokasi memori di dalam heap space-nya yang tidak memiliki memori fisik yang dipetakan kepadanya. Hal ini kebanyakan terjadi karena page dari memori fisik telah diambil sebelumnya oleh page scanner sebagai akibat dari keterbatasan memori. 1. Sebuah reference dibuat ke alamat memori yang tidak memetakan ke page fisik dari memori. Pada contoh ini, page telah keluar dan sekarang berada di swap device. 2. Ketika proses mengakses alamat tanpa yang tidak ada di memori fisik, MMU mendeteksi invalid reference dan mengakibatkan sebuah trap terjadi pada prosesor yang mengeksekusi kode dari thread yang sedang berjalan. Fault handles mengenali ini sebagai memory page fault dan membangun segmen tempat terjadinya fault 14

dengan membandingkan alamat dari fault ke alamat yang dipetakan oleh setiap segmen. 3. Address space as_fault() rutin membandingkan alamat fault dengan alamat yang dipetakan oleh setiap segment, kemudian memanggil page_fault dari segment driver untuk segmen ini (dalam kasus ini, vnode segment driver). 4. Segment driver mengalokasikan dan memetakan page dari memori dengan memanggil ke HAT layer dan mengyalin isi page dari swap device. 5. Segment driver kemudian membaca page dari backing store dengan memanggil fungsi getpage() dari backing store vnode. 6. Backing store untuk segmen ini adalah swap device, sehingga fungsi swap device

getpage() dipanggil untuk membaca page dari swap device. 2.2 Memori SegmentContoh lain yang menggunakan pendekatan berorientasi objek untuk manajemen memori adalah objek segmen memori. Segmen memori mengatur pemetaan cakupan linear pada virtual memory ke address space. Pemetaan tersebut di antara address space dan beberapa tipe dari device. Tujuan dari segmen memori adalah untuk mengijinkan memory dan device untuk dipetakan ke address space. Secara tradisional, hal ini membutuhkan hard-coding memory dan informasi device ke pengatur address space untuk tiap device. Arsitektur objek mengijinkan tingkah laku berbeda untuk segmen yang berbeda. Untuk mengimplement sebuah address space, implementasi segment driver butuh untuk menyediakan hal berikut: fungsi untuk membuat pemetaan bagi cakupan linear address, rutin page fault handling, dan satu fungsi untuk menghancurkan pemetaan. Fungsi-fungsi ini menjadi sebuah package dalam segment driver, yang merupakan instantiasi dari segment object interface. Gambar berikut mengilustrasikan hubungan antara address space dan segmen serta menunjukkan pemetaan segment dari heap space pada proses.

15

Gambar 2.7 Segment Interface Segment driver mengimplement subset dari method yang dideskribsikan pada tabel Solaris Segment Methods. Fungsi dalam struktur operasi segment, s_ops, mengacu pada fungsi dalam vnode segment driver dan merupakan prefix dengan

segvn. Objek segmen dibuat ketika subsistem lain akan membuat pemetaan denganmemanggil as_map() untuk membuat pemetaan pada alamat tertentu. Segment membuat rutin yang dilewatkan sebagai argument untuk as_map(), objek segmen dibuat, dan pointer objek segmen dikembalikan. Ketika objek segmen dibuat, bagian lain dari sistemm virtual memory dapat memanggil ke segment untuk operasi address space yang berbeda tanpa mengetahui segment driver menggunakan operasi method segment untuk apa. Kernel solaris diimplementasikan dengan cakupan dari segment driver untuk bermacam fungsi. Tipe driver yang berbeda ditunjukkan pada tabel Solaris Segment Driver. Kebanyakan dari proses pemetaan address space, termasuk executable text, data, heap, stack dan memory mapped files, dijalankan dengan vnode segment driver,

seg_vn. Tipe pemetaan lain yang tidak memiliki cnode yang berhubunganmembutuhkan segmen driver yang berbeda. Segment driver yang lain berhubungan dengan pemetaan kernel memori atau hardware device, seperti graphics adapters.

16

Tabel 2.3 Solaris Segment Driver Segmentseg_vn seg_kmem seg_kp

seg_spt

seg_map

seg_dev seg_mapdev seg_lock

seg_drv seg_nf seg_mdi seg_sx

Fungsi Pemetaan vnode kedalam proses address space diatur dengan device driver seg_vn. segmen dari nonpageable kernel memory dialokasikan. Segmen dari pageable kernel memori dialokasikan. Hanya terdapat sedikit kernel yang pageable; kernel thread stacks dan TNF buffer merupakan consumer utama dari pageable kernel memory. Shared page table segment driver. Fast System V shared memory dipetakan ke address space process dari segment driver ini. Memori dialokasikan dari driver ini juga dikenal sebagai Intimate Shared Memory (ISM). Kernel menggunakan seg_map driver untuk memetakan files (vnode) kedalam kernels address space, untuk mengimplement file system caching. Memetakan hardware device Mapping support untuk memetakan hardware device melalui interface ddi_mapdev(9F). Mapping support untuk hardware graphics device yang dipetakan diantara user dan kernel address space. Mapping support untuk memetakan hardware graphics device. Nonfaulting kernel memory driver. Hardware mapping support untuk cgfourteen graphics frame buffer. Hardware mapping support untuk SPARCstation 20 SX graphics frame buffer.

Segmen v_node: seg_vnSegment driver yang paling banyak digunakan adalah segment driver v_node,

seg_vn. seg_vn driver memetakan files (atau vnodes) kedalam proses address space,menggunakan physical memory sebagai cache. Segment driver seg_vn juga membuat

17

memori anonym dalam proses address space untuk heap dan stack dan menyediakan support bagi system V shared memory. Segment driver seg_vn mengatur pemetaan berikut kedalam proses address space:

Executable text Executable data Heap dan stack Shared libraries Mapped files

Memory Mapped FilesFile dapat dipetakan ke process address space dengan system call mmap. Ketika memetakan file ke address space, vnode segment dipanggil. Vnode segment menangani translasi alamat memori dan page faults bagi memory range yang diminta dalam system call mmap, dan segment baru ditambahkan ke daftar segment dalam proses address space. Ketika segment dibentuk, driver seg_vn menfinisialisasi struktur segment dalam alamat dan panjang pemetaan, kemudian membuat spesifik struktur data

seg_vn dalam struktur segmen field s_data. Spesifik struktur data seg_vnmenyimpan semua informasi driver seg_vn yang dibutuhkan untuk menangani pemetaan alamat bagi segment. Struktur data spesifik seg_vn (struct segvn_data) memiliki pointer ke

vnode yang dipetakan dan ke memori anonym yang telah dialokasikan untuk segmenttersebut. File sistem melakukan pemetaan file terbanyak ketika peta terbentuk. Sebagai hasil, driver seg_vn cukup simple, kebanyakan pekerjaan seg_vn selesai ketika pembuatan dan penghapusan peta. Implementasi yang lebih kompleks dari driver seg_vn adalah kemampuannya menangani memori anonym page dalam segment. Ketika peta file dibuat, vnode dan

offset diletakkan dari file yang dipetakan ke anggota struktur data segvn_data, vpdan offset. Struktur data seg_vn ditunjukkan pada Gambar berikut.

18

Gambar 2.8 seg_vn Segment driver relationship Pembuatan peta bagi file diselesaikan dengan system call mmap(), yang memanggil method map bagi file system yang memiliki file yang dimaksud.

Shared Mapped FilesArsitektur address space segment membuat mudah bagi dua atau lebih proses untuk memetakan file yang sama kedalam address spacenya. Ketika memetakan files kedalam dua atau proses, dibuat segment seg_vn ke tiap proses yang menunjuk ke

vnode yang sama. Tiap proses memiliki peta virtual memory ke file tersendiri, tetapisaling berbagi physical memory pages yang sama bagi files. Segment pertama menyebabkan page fault dalam membaca sebuah page ke physical memory, yang kedua dan selanjutnya kemudian membuat reference ke physical memory page yang tersedia sebagai lampiran. Gambar shared mapped files menunjukkan bagaimmana proses dapat memetakan file yang sama. Setiap proses membuat segment object tersendiri, tetapi tiap segmen merujuk pada file yang sama dan dipetakan ke physical pages yang sama. 19

Gambar 2.9 Shared Mapped Files

2.2.1

Copy on Write

Proses copy-on-write terjadi ketika proses menulis ke page yang dipetakkan dengan

MAP_PRIVATE. Proses ini mencegah peta lain ke page untuk melihat perubahan yangdibuat. seg_vn mengimplements copy-on-write dengan mengature ijin pada hardware MMU dari segment menjadi read only dan mengatur ijin pada segment menjadi read write. Ketika proses melakukan penulisan pada peta yang diatur seperti ini, MMU menghasilkan exception dan mengakibatkan page fault pada page. Page fault handler pada seg_vn mencari mode proteksi bagi segment, jika dipetakan secara private dan read write, kemudian handler menginisiasi copy-on-write. Copy-on-write melakukan unmaps pada shared vnode page dimana kegagalan terjadi, membuat page memori anonym pada alamat tersebut, dan menyalin konten dari page lama ke page anonym baru. Semua hal ini terjadi dalam kontekks page fault, sehingga proses tidak pernah tau apa yang terjadi di dalamnya. Operasi copy-on-write memiliki tingkah laku yang sedikit berbeda di bawah kondisi memori. Ketika memori low, disbanding membuat physical memory page baru, copy-onwrite mengambil page dari offset file dan menamainya menjadi page anonym baru. Hal ini hanya terjadi ketika free memory lebih rendah dari minfree parameter sistem.

20

2.2.2

Page Protection and Advice

seg_vn mendukung mode proteksi memori baik pada segment keseluuruhan atauindividual page dalam segment. Pada keseluruhan segment diimplementasikan oleh anggota struktur segvn_data, prot; yang dapat pengoperasiannya menggunakan switch Boolean, pageprot, pada struktur segvn_data. Jika pageprot sama dengan 0, mode proteksi keseluruhan segment diatur oleh prot, selain itu proteksi page-level dinyalakan. Proteksi page-level diimplementasikan dengan array page yang dirujuk oleh struktur vpage. Jika proteksi page-level dinyalakkan, kemudian vpage mengacu ke struktur vpage array. Setiap page yang memungkinkan pada address space memiliki satu nilai array, yang berarti jumlah anggota vpage adalah ukuran segment virtual address space dibagi dengan ukuran fundamental page bagi segment. Isi vpage dari tiap page menggunakan standar proteksi memori dari tabel mmap Shared Mapped File Flags. Setiap struktur vpage juga digunakan untuk mengimplement memory. Tabel 2.4 mmap Shared Mapped File Flags Flag MAP_SHARED Mode Proteksi Hasil

PROD_READ | Modifikasi terlihat pada semua proses PROT_WRITE sharing dari pemetaan.

MAP_PRIVATE

PROT_READ | Modifikasi hanya terlihat oleh proses PROT_WRITE yang memetakan file. Proses copy-onwrite membuat page pada memori anonym dan memberikan private copy bagi proses.

2.3 Swap LayerSetiap physical page dari memori untuk identifikasi vnode dan offset. Identifikasi vnode dan offset didukung oleh store pada physical memory. Swap space menggunakan backing store untuk anonymous pages pada memory anonym page pada memory.

21

Karena swap space digunakan sebagai backing store untuk anonym memory, kita menggunakan swap space untuk pages pada saat swap out. Kita memesan space up-front ketika membuat mapping oleh anonym memory untuk heap space, stack dan menulis mapped file dengan MAP_PRIVATE set. Solaris kernel membolehkan anonymous memory memesan physical swap space ketika memory yang ada diproses. Impelemntasi Swap menggunakan swapfs untuk implementasi alokasi swap.

Swapsf file system merupakan pseudo file system antara anon layer dan physical layer swap device. Swapfs file system bertindak sebagai swap space dibelakang page jika physicalswape space sedang di alokasikan.

2.3.1

Swap Allocation

Beberapa menit steps selanjutnya dan melihat bagaimana swap di alokasikan dan selesai proses, kita dapat melihat bagaimana swapsf di implementasikan. Melihat swap space untuk segment driver sebagai Virtual swap space dan real (disk atau file) swap space serta physical swap space. Alokasi swap space sebagai : reserve , allocate dan swap-out. Ketika pertama kalai membuat segmen kita memesan virtual space dan ketika pertama kali menyentuh dan mengalokasikan page, kita allocation virtual space untuk page dan kemudian memesan memory storage kita dapat swap-out page untuk swap space. Tabel 2.5 Alokasi swap spaceState Reserved Deskripsi Virtuap swap space untuk memesan untuk seluruh segmen. Pemesanan terjadi ketika segmen dibuat dengan private/read/write akses. Pemesanan menggambarkan virtual sizw pada area dibuatnya. Allocated Vietual Swap Space di alokasiskan ketka pertama kali physical page di tugaskan. Pointnya adalah swapsf vnode dan proses mengimbangi ke anon slot Swapped Out Ketika terjadi kekurangan memory, page kemungkinan men-swapped keluar page scanner. Swap out terjadi ketika page scanner memanggil swapfsputpage untuk page. Page dipindahkan ke pyisical disk

22

2.3.2

Impelementasi Swapfs

Swapfs file system menggunakan global variable availrmen untuk tetap menyediakan physical memory pada system dan menambah jumlah dari swap space yang ada.ketika memesan virtual swap, dilakukan pengurangan jumlah pada virtual memory yang ada untuk pool. Semua memry dan phiscal swap yang ada sukses dialokasikan. Itu tidak sampai kemudian menugaskan physical swap space. Membuat private segmen, kita memesan swap dan alokasi anon struktrur. Semua yang terjadi sampai real memory page membuat hasil ZFOD atau copy-on-write(COW). Ketika physical page melakukan kesalahan maka diidentifikasi dengan menggunakan vnode/offset yang mana untuk anonym memory pada virtual swap device untu page. Dibawah ini dapat dilihat anon point pada swapsf.

Gambar 2.10 anon slot inisialisasi pada virtual swap sebelum page-out

2.4 Global Page ManajemenPages adalah unit fundamental dalam memory fisik dalam Solaris memory

management subsystem. Manajemen Global Page membahas tentang struktur, bagaimana pengalokasian dan seberapa bebas list manage pools dari page pada sistem.

3.4.1 PagesMemori Fisik terbagi menjadi beberapa pages. Setiap page yang aktif pada Solaris Kernel adalah suatu pemetaan antara file (vnode) dan memory; Page dapat diidentifikasi dengan vnode pointer dan ukuran page offset dalam vnode. Suatu identitas page adalah pasangan vnode/offset. Pasangan Vnode/offset merupakan suatu backing store untuk page yang merepresentasikan file dan offset dimana page dipetakan. 23

Hardware address translation (HAT) dan pengalamatan space layer mengatur pemetaan antara physical page dan alamat space virtual. Properti utama dari vnode/offset adalah kegunaan kembali, oleh karena itu penggunaan kembali tiap physical page untuk tugas yang lain dengan menyederhanakan konten sinkronisasi pada RAM dengan backing store (vnode dan offset) sebelum page digunakan kembali. Sebagai contoh, kita dapat menggunakan page dari heap memory dari suatu proses dengan menyederhanakan peng-copy-an konten ke dalam vnode dan offset, dimana pada kasus ini akan dicopy ke dalam swap device. Mekanisme yang sama digunakan untuk caching file, dan menyederhanakan penggunaan pasangan

vnode/offset untuk mereferensikan file pada page yang akan dicachekan pada file regular kemudian menyederhanakan proses sinkronisasi page dengan backing store (jika page telah dimodifikasi) atau hanya reuse page jika tidak dimodifikasi dan tidak membutuhkan proses sinkronisasi kembali dengan backing store.

Gambar 2.11 Struktur page

3.4.2 Page Hash ListPada Virtual Machine system hash page dengan identitas (pasangan valid vnode/offset ) kedalam global hash list sehingga mereka dapat dialokasikan dengan vnode dan offset. Tiga fungsi page untuk mencari global page hash list adalah sebagai berikut: page_find(), page_lookup(), dan page_lookup_nowait(). Fungsi ini mengambil suatu vnode dan offset sebagai argument dan mengembalikan pointer untuk suatu struktur page jika menemukannya. 24

Global hash list adalah suatu array dari pointer untuk menghubungkan list dari page. Fungsi menggunakan suatu hash untuk mengindeks kedalam array page_hash untuk mengalokasikan list dari pages yang terdiri dari page yang cocok dengan pasangan vnode/offset. Gambar 2.12 menunjukkan bagaimana fungsi page_find() mengindeksnya kedalam array page_hash untuk mengalokasikan suatu page yang cocok yang diberikan oleh vnode/offset.

Gambar 2.12 Pengalokasian page dengan Vnode/offset identity Page_find() mengalokasikan suatu page sebagai berikut: 1. Mengkalkulasi slot pada array page_hash yang terdiri dari list page potensial dengan menggunakan PAGE_HASH_FUNC macro, yang terlihat seperti berikut ini:#define PAGE_HASHSZ #define PAGE_HASHAVELEN #define PAGE_HASHVPSHIFT #define PAGE_HASH_FUNC(vp, off) \ ((((uintptr_t)(off) >> PAGESHIFT) + \ ((uintptr_t)(vp) >> PAGE_HASHVPSHIFT)) & \ (PAGE_HASHSZ - 1)) page_hashsz 4 6

2. Menggunakan makro PAGE_HASH_SEARCH, seperti yang diperlihatkan dibawah ini untuk mencari list referensi dengan slot untuk proses pencocokan vnode/offset. Makro melintasi linked list dari page hingga ia menemukan suatu page.

25

ine PAGE_HASH_SEARCH(index, pp, vp, off) { \ for ((pp) = page_hash[(index)]; (pp); (pp) = (pp)->p_hash) { \ if ((pp)->p_vnode == (vp) && (pp)->p_offset == (off)) \ break; \ } \

3.4.3 MMU-Specific Page StructuresDefinisi dari struktur hampir sama meskipun pada platform yang berbeda dan meskipun tidak terdiri dari struktur mesin yang spesifik. Akan tetapi, diperlukan untuk menjaga agar mesin spesifik dari data tiap pagenya, sebagai contoh informasi HAT mendeskripsikan bagaimana pade dipetakan oleh MMU. Kernel membungkus struktur page mesin-independen dengan suatu struktur page mesin-spesifik, struct machpage. Konten dari suatu strukur page mesin-spesifik disembunyikan dari kernel generik, hanya lapisan HAT mesin-spesifik yang dapat melihat atau memanipulasi isi atau kontennya. Gambar 2.13 memperlihatkan bagaimana tiap struktur page diembededkan dalam suatu dependent-mesin struct machpage.

Gambar 2.13 Contoh Struktur Page Mesin-spesifik : sun4u Page machine-spesifik terderi dari suatu pointer ke HAT-spesifik untuk memetakan informasi, dan informasi tetang kondisi HAT page di masukkan pada mesin spesifik machpage. Pemasukkan Informasi ini termasuk didalamnya bit-bit yang mengindikasikan apakah page telah berhasil direferensikan atau dimodifikasi, untuk digunakan pada page scanner. Keduanya baik mesin-independen dan mesin-dependent 26

struktur page berbagi alamat memori start yang sama, sehingga pointer untuk page structure dapat dibungkus kedalam pointer untuk page struktur mesin-spesifik, gambar 2.13. Makro untuk mengkonversi antara struktu page mesin independent dan mesindependent adalah dengan membuat cast.

3.4.4 Physical Page listSolaris kernel menggunakan global physical page list, yang terdiri dari segmentasi yang berdampingan dengan physical memory. (Banyak platform hardware sekarang menampilkan memori yang tidak berdampingan secara kelompok). Bagian physical memory ditambahkan selama sistem melakukan booting. Selain itu penambahan dan penghapusan secara dinamik ketika physical memory ditambahkan atau dihilangkan ketika sistem di jalankan. Gambar 2.14 menunjukkan penyusunan physical page list kedalam bagian yang berdampingan.

Gambar 2.14 Contiguous Physical Memory Segments

3.4.5 Page-Level InterfaceSolaris virtual memori sistem mengimplementasikan pengelompokkan

manajemen dan memanipulasinya kedalam pusat fungsi kelompok. Fungsi ini digunakan untuk mensegmentasi driver, dan file system untuk menciptakan, menghapus, dan memodifikasi page. Bagian paling besar dari page-level interface ditunjukkan pada tabel 2.6. Fungsi page_create_va() mengalokasikan page. Hal ini mengambil sejumlah page untuk mengalokasikannya sebagai argument dan mengembalikannya sebagai suatu page linked list dengan page yang telah diambil dari 27

free list. page_create_va() juga mengambil suatu alamat virtual sebagai argumen sehingga hal ini dapat mengimplementasikan pewarnaan terhadap page. Fungsi page_create_va() baru menggantikan page_create() lama dan harus digunakan oleh seluruh subsystem yang baru dikembangkan karena page_create() mungkin tidak mewarnai secara benas page yang dialokasikan.

3.4.6 Page SizeKernel Solaris menggunakan page size fundamental yang bermacam-macam yang berjalan diatas hardware. Pada Ultra Sparc dan yang lainnya, page size fundamental adalah 8 Kbytes. Hardware dimana Solaris berjalan memiliki banyak tipe memori management unit yang berbeda, dimana mendukung variasi dari page size,

sebagaimana yang dirinci pada Tabel 2.6. Tabel 2.6 Page Size pada different Sun Platform

Optimal MMU page size adalah sebuah trade off antara performance dan efisiensi size memory. Suatu page size yang lebih besar memilki manajemen memori yang berlebihan dan oleh karena itu performa lebih baik, akan tetapi memilki page size yang lebih kecil membuang memory yang lebih sedikit (memori terbuang ketika page tidak secara sempurna terisi).

3.4.7 Pageout ProcessKomponen tambahan dari sistem VM (virtual memory) adalah pageout scanner. Komponen ini diinstal saat boot-time sebagai proses kernel. Tugasnya adalah membebaskan memori saat jumlah free memori dibawah batas ambang tertentu. Karena Solaris menggunakan sistem VM untuk buffer file, sebuah sistem dengan aktivitas I/O akan dengan cepat menggunakan free memory yang tersedia untuk buffering, yang menyebabkan jumlah free memory turun ke batas ambang. Ketika sampai ke angka batas ambang tertentu, maka pageout scanner dipanggil. 28

Dasar Operasi Pageout scanner Pageout scanner berdasarkan kode umum yang diterapkan di Unix System V Release 4, dan banyak platform lainnya. Kode ini menggunakan model NRU (Not Recently Used) yang memindai page-page yang tersedia untuk mencari page yang tidak diacu sejak pengecekan terakhir. Pageout daemon memeriksa 4 kali per detik untuk melihat jika free memory menurun di bawah lostfree, sebuah parameter yang telah diset sebelumnya mengatur pageout scanner. Scanner juga dibangunkan saat ada permintaan memori dan free memory di bawah batas ambang. Jika memori lebih rendah daripada batas ambang, scanner dipanggil. Scanner bertanggung jawab untuk memutuskan page mana di memori yang akan dibebaskan.

3.4.8 Pageout ScannerScanner menggunakan analogi two handed clock (dua jarum jam), dimana keseluruhan memori fisik direpresentasikan dengan 12 jam pada putaran jam. Terdapat 2 jarum yang berputar pada jam dengan kecepatan sama, salah satunya sedikit lebih maju dari yang lainnya. Saat jarum berputar, jarum di depan menghapus flag yang diacu di dalam page. Jarum di belakang lalu memeriksa page tersebut, apakah page telah diacu (karena jarum di depan menghapus flag). Jika page belum diacu atau diubah, maka page tersebut merupakan kandidat untuk dibebaskan. Hal ini dapat diilustrasikan pada gambar berikut.

Gambar 2.15 Pageout Scanner

29

3.4.9 Pageout Scanner ParameterParameter yang mengontrol jarum jam melakukan 2 hal, yaitu: 1. Mengontrol kecepatan scanner memindai page-page 2. Mengontrol waktu (jarak) antara jarum di depan dan jarum di belakang. Jarak tersebut adalah handspreadpages, dan dalam satuan page. Scanner memulai pemindaian saat terdapat page sejumlah lostfree - deficit yang free pada kecepatan slowscan page per detik. Deficit merupakan parameter internal yang secara dinamis diatur oleh kernel untuk mengindikasikan ke sistem VM berapa banyak page yang diperlukan dari aktivitas terkini. Kecepatan scanner memindai naik secara linier antara lostfree dan batas ambang minimal (treshhold), minfree.

Gambar 2.16 Parameter Pageout Scanner Jika jumlah free memory dibawah desfree, scanner berjalan pada setiap clock cycle, atau secara default 100 kali dalam sedetik. Hal ini membantu scanner untuk menjaga sedikitnya desfree page pada free list. Setelah scanner mulai, scanner akan tetap berjalan untuk desscan page. Parameter desscan secara normal diatur ke jumlah page yang diperlukan scanner untuk memindai untuk mencapai kecepatan antara slowscan dan fastscan yang diperlukan.

30

Terdapat hubungan lain dalam bagian sistem lainnya sehingga jika sejumlah memori yang besar diperlukan, needfree diatur untuk merefleksikan jumlah yang diperlukan dan desscan akan berjalan untuk memindai fastscan page. Parameter lainnya, maxpgio, membatasi kecepatan yang I/O mengantri ke swap device. Parameter ini diset rendah untuk mencegah kejenuhan swap device. Parameter ini secara default bernilai 40 I/O per detik pada arsitektur sun4c, dan 60 I/O per detik pada arsitektur sun4d dan sun4u. Pengaturan default sering tidak mencukupi untuk sistem modern, dan harus diset hingga 100 kali jumlah kumparan swap. Karena pageout daemon juga mem-page out I/O request, parameter ini juga membatasi kecepatan yang mana pageout dapat menulis I/O. I/O request secara normal diantrikan dan ditulis oleh proses user, dan karena itu tidak berpengaruh pada maxpgio. Saat ada kekurangan memori, pageout scanner mengeluarkan banyak I/O writes, dan maxpgio terkadang dapat menjadi faktor yang membatasi. Tabel berikut merupakan daftar parameter yang mengontrol proses pageout pada Solaris. Tabel 2.7 Parameter Pageout

ParameterLostfree

DeskripsiJika free memori di bawah lostfree maka pageout scanner mulai 4 kali/detik, pada kecepatan slowscan page/detik Jika free memory di bawah desfree, maka pageout scanner dimulai 100 kali/detik. Waktu saat kecepatan scan diatur ke fastscan. Kecepatan scan adalah interpolasi linear antara lostfree (kecepatan scan = slowscan) dan minfree. Jumlah saat rutin page_create menyebabkan pemanggilnya menunggu hingga free page tersedia. Kecepatan page dipindai per detik saat free memory = minfree. Diukur dalam page. Kecepatan page dipindai per detik saat free memory = lostfree. Jumlah page yang scanner perhitungkan yang perlu dipindai setiap kali scanner terbangun untuk mencapai kecepatan scan 31

Desfree

Minfree

Throttlefree

Fastscan

Slowscan

Desscan

Parameteryang diinginkan.Maxpgio

Deskripsi

Panghambat untuk jumlah maksimal page per detik yang dapat ditangani oleh swap device. Jumlah page antara jarum di depan yang mengapus reference bit dan jarum di belakang yang mengecek bit reference. Jumlah page yang dihitung. Ditambahkan ke peningkatan lostfree.

Handspreadpages

Phbysmem Deficit

Terdapat pula apitan utilisasi CPU pada kecepatan scan, untuk mencegah pageout daemon menggunakan banyak waktu prosesor. Ada 2 batasan internal yang mengatur waktu CPU yang diinginkan dan waktu CPU maksimal yang seharusnya digunakan scanner. Pada kondisi ideal, scanner akan mencoba menggunakan 4% waktu CPU untuk memindai pages. Jika ada kekurangan memori yang kritis dan kecepatan scan meningkat, kecepatan akan dibatasi agar scanner tidak menggunakan lebih dari 80% dari sebuah CPU tunggal.

2.5

Memory SchedulerSwap-out sebuah proses melibatkan penghapusan semua struktur thread proses

dan private pages dari memori, dan pengaturan flag di dalam tabel proses untuk mengindikasikan bahwa proses ini telah di-swap out. Ini bukanlah cara yang mahal untuk menghemat memori, tetapi mempengaruhi performance proses secara dramatis, dan karena itu hanya digunakan saat paging gagal untuk membebaskan cukup memori secara konsisten. Memory scheduler dipanggil pada saat boot time, dan tidak melakukan apapun, selain saat free memory kurang dari desfree memory (rata-rata 30 detik). Pada saat ini memory scheduler memulai pencarian proses mana yang dapat di-swap out secara penuh. Memory scheduler akan melakukan soft-swap out proses jika ada kekurangan yang minimal, atau hard-swap proses jika ada kekurangan yang lebih besar.

32

2.5.1

Soft Swapping

Soft swapping terjadi pada saat rata-rata 30 detik free memory di bawah desfree. Pada saat ini memory scheduler akan mencari proses yang sudah tidak aktif selama paling sedikit maxslp detik. Ketika memory scheduler menemukan sebuah proses yang telah sleeping selamamaxslp detik, memory scheduler men-swap out struktur thread untuk setiap thread, lalu

mem-page out semua private pages dari memori untuk proses tersebut. 2.5.2 Hard Swapping

Hard swapping terjadi saat: 1. Terdapat paling tidak dua proses pada run queue yang sedang menunggu CPU. 2. Rata-rata free memory di atas 30 detik kurang dari desfree. 3. Terdapat paging yang berlebihan (ditentukan menjadi true jika pageout + pagein > maxpgio) Ketika hard swapping dipanggil, langkah yang dilakukan adalah kernel diminta untuk meng-unload semua modul dan cache memory yang sedang tidak aktif, diikuti dengan men-swap out proses secara urut hingga jumlah free memory yang diinginkan dicapai.

33

BAB III KESIMPULAN

Virtual Memori merupakan teknik yang memisahkan antara memori dan memori fisiknya (Physical Memory). Dimana menyembunyikan aspek-aspek fisik memori dari penggina dan dengan menjadikan memori sebagai likasi alamat virtual yang berupa byte yang tidak terbatas dan menaruh beberapa bagian dari memoru virtual yang berada di memori. Setelah penjelasan secara rinci tentang solaris pada bab III dapat di tarik kesimpulan bahwa secara garis besar fungsi dari virtual memory pada solaris adalah 1. Virtual 2. Swaping 3. Requirement Sehingga dengan virtual memory dapat menjaga frekwensi partisi dari memori untuk kecepatan primary storage pada Sistem Operasi Solaris. Selain itu pada solaris setiap proses paling tidak memiliki empat segmen yaitu : executable text, executable data, Heap space, process stack.

34

DAFTAR PUSTAKA

Cromar Scott, 2000, SolarisTroubleshooting Handbook, CreatSpace. Dimatos, Demetrios dan Hapuarachchi Madhujith, 2011. Kurniawan Hery, 2010, Virtual memory. Mauro, Jim dan McDougall,2000, Richard., Solaris internals , Sun Microsystem Computer Company,1998, The Solaris Memory System. Silberschatz, 2005, Operating System Concept, seven edition.

35