OS Syimbian
Upcoming SlideShare
Loading in...5
×
 

OS Syimbian

on

  • 3,339 views

 

Statistics

Views

Total Views
3,339
Views on SlideShare
3,339
Embed Views
0

Actions

Likes
0
Downloads
50
Comments
0

0 Embeds 0

No embeds

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

OS Syimbian OS Syimbian Presentation Transcript

  • ! quot; # $ % &' '' & ' () ' ) % &' '& ) ) &' + '* &' ', ) ) $ -' * &' + '' ) $ &' .0/' &' ' + ) '' 1 .' &' % '& &' '* $ */ /' *& /' $2 /' /' .' .' 3 3 '45* ' ' 6 &'1 & 7&' 8 -' * 1 0 1 91 0 8 ( 1 /' &' '' &' & '9 ! ) 1 / &' ' /' ( .0 /' *0 /' 1 .' &' '& '' '' 1 .' &' '* $ 4 ( $ 8 : /' 1 ' /' . /& 1 ' /' . . ' 1.' .' $2 1/ * / ; / '1/ / '* & . 0 1/ /' * 0 ; / '1/ / '* ' & '9 1/' &' &'9 ; 1/' 6 6 ' 8 1/ && 6 6 ' 1/ &0 6 6 ' 1/ ' 3 1/ 3 1/ 2 $+ ' 1/ < .' 4 5 * 1.' ' ' 1.' ' ' 1.' ' 7 & 1.' ' ! & 1 ; *& ) 7- ) 1 + 1$ 1 = + >quot; > # ! ) 1 1 ) 1 ) $ quot;9 ; %? 6 #9 % quot; 4 ?+ # 7 @ 1$ 1 $ 1 9 1 7? 1 1 $ 1 : $ ( $ ( $ $
  • $ ! ( $ ( $ < ( *& 1 $ > ( $ + $ 7 ) 1 4 1 $ 1 $ : $ 9AA ) (= ( = $ 7 ?quot; 7 ? ( # ) $ $ ) ( $ 1 1 = + ) 1 ) : $ ) ) ( ( $ $ ($ $ ( ( ( 1 ( $ +- quot; 1 6+ + 6 -( + #+ - 6+ ( ( ( ( $ +- 6+ : $ 9 ( 9 ( ( $ $ 5 B $ $ 4 $ : $ ? ( $ quot; * ?7, % <> %# ( 6= %= $ quot;2 1 & $ &02 *2 # $ quot; 9 ; C7 4 %? ?+7 # $ quot; <% % C%> ># ( $ $ quot; 1 ( ( # $ ) = quot;4 3 # $ quot; ( 1 # $ ? quot; # $ 1 quot; AA D 1 C7 9 # $ 9 $ quot; ; $ # Saya akan menulis ringkasan sedikit tentang definisi Sistem Operasi yang sebagian besar diambil dari buku Operating Systems: Design and Implementation (OSDI), karya Andrew S. Tanenbaum. Buku ini umumnya dijadikan referensi mata kuliah
  • Sistem Operasi di lingkungan universitas khususnya jurusan Ilmu Komputer, Teknik Informatika, Teknik Elektro, dan yang berhubungan. Kita akan mendapati bahwa buku lain karya penulis yang sama berjudul Modern Operating Systems (MOS) juga memberikan ulasan yang senada dengan buku ini, meskipun kalau kita amati buku MOS lebih luas menjelaskan lagi tentang sistem operasi multimedia, sistem multiprosesor, keamanan, studi kasus: UNIX, Linux, Windows 2000, dan desain sistem operasi. OSDI cenderung ke arah practical, diarahkan ke sistem operasi MINIX, sedangkan MOS “lebih bebas”. Sistem komputer terdiri dari perangkat keras dan lunak. Perangkat keras atau secara umum sering kita menyebutnya dengan komputer saja, tidak berarti apa-apa tanpa perangkat lunak. Komputer membutuhkan perangkat lunak untuk melakukan operasi menyimpan, menjalankan aplikasi, mendapatkan informasi, sampai dengan bermain games. Perangkat lunak secara kasar terbagi menjadi dua yaitu program sistem yang berguna untuk mengatur operasi komputer dan program aplikasi yang berguna untuk memberikan solusi kepada pengguna. Sistem operasi masuk ke dalam program sistem dan merupakan perangkat lunak paling dasar yang berguna untuk mengontrol sumber daya komputer dan memberikan dasar bagi program aplikasi untuk dibuat atau dijalankan.
  • Mesin virtual sebenarnya bukan merupakan hal yang baru dalam dunia komputer. Mesin virtual biasa digunakan dalam dunia komputer untuk memecahkan beberapa masalah serius, namun sesungguhnya mesin virtual adalah nyata penggunaanya untuk pengguna komputer karena mesin virtual secara khas telah digunakan dalam program aplikasi yang biasa digunakan sehari-hari. Beberapa masalah tersebut misalnya pembagian hardware yang sama yang diakses banyak program atau untuk memungkinkan perangkat lunak agar lebih portabel di antara berbagai jenis sistem operasi. Dalam bab ini kita akan membahas tentang mesin virtual beserta penerapannya dalam sistem operasi, khususnya mesin virtual Java, yang dewasa ini sangat populer dalam ilmu komputer. --------------------------------------------------------------------- 8.1 Konsep Mesin Virtual Dasar logika dari konsep mesin virtual atau virtual machine adalah dengan menggunakan pendekatan lapisan-lapisan (layers) dari sistem komputer. Sistem komputer dibangun atas lapisan-lapisan. Urutan lapisannya mulai dari lapisan terendah sampai lapisan teratas adalah sebagai berikut : 1. Perangkat keras 2. Kernel 3. Sistem program Kernel, yang berada pada lapisan kedua, menggunakan instruksi perangkat keras untuk menciptakan seperangkat system call yang dapat digunakan oleh komponen- komponen pada level sistem program. Sistem program kemudian dapat menggunakan system call dan perangkat keras seolah-olah pada level yang sama. Meski sistem program berada di level tertinggi, namun program aplikasi bisa melihat segala sesuatu di bawahnya (pada tingkatan) seakan-akan mereka adalah bagian dari mesin. Pendekatan dengan lapisan-lapisan inilah yang kemudian menjadi kesimpulan logis pada konsep mesin virtual atau virtual machine (VM). [Gambar 8-1. Struktur Mesin Virtual] Sumber: http://utenti.lycos.it/yanorel6/2/ch52.htm Kelemahan Mesin Virtual ----------------------- Kesulitan utama dari konsep VM adalah dalam hal sistem penyimpanan dan pengimplementasian. Sebagai contoh, kesulitan dalam sistem penyimpanan adalah sebagai berikut. Andaikan kita mempunyai suatu mesin yang memiliki 3 disk drive namun ingin mendukung 7 VM. Keadaan ini jelas tidak memungkinkan bagi kita untuk dapat mengalokasikan setiap disk drive untuk tiap VM, karena perangkat lunak untuk mesin virtual sendiri akan membutuhkan ruang disk secara substansi untuk menyediakan memori virtual dan spooling. Solusinya adalah dengan menyediakan disk virtual, atau yang dikenal pula dengan minidisk, di mana ukuran daya penyimpanannya identik dengan ukuran sebenarnya. Sistem disk virtual mengimplementasikan tiap minidisk dengan mengalokasikan sebanyak mungkin track dari disk fisik sebanyak kebutuhan minidisk itu. Secara nyata, total kapasitas dari semua minidisk harus lebih kecil dari kapasitas disk fisik yang tersedia. Dengan demikian, pendekatan VM juga menyediakan sebuah antarmuka yang identik dengan underlying bare hardware. VM dibuat dengan pembagian sumber daya oleh physical computer. Pembagian minidisk sendiri diimplementasikan dalam perangkat lunak.
  • Kesulitan yang lainnya adalah pengimplementasian. Meski konsep VM cukup baik, namun VM sulit diimplementasikan. Ada banyak hal yang dibutuhkan untuk menyediakan duplikat yang tepat dari underlying machine. VM dapat dieksekusi hanya pada user mode, sehingga kita harus mempunyai user mode virtual sekaligus monitor mode virtual yang keduanya berjalan di physical user mode. Ketika instruksi yang hanya membutuhkan virtual user mode dijalankan, ia akan mengubah isi register yang berefek pada virtual monitor mode, sehingga dapat me-restart VM tersebut. Sebuah instruksi M/K yang membutuhkan waktu 100 ms, dengan menggunakan VM bisa dieksekusi lebih cepat karena spooling atau dapat pula lebih lambat karena interpreter. Terlebih lagi, CPU menjadi multiprogrammed di antara banyak VM. Jika setiap user diberi satu VM, dia akan bebas menjalankan sistem operasi (kernel) yang diinginkan pada VM tersebut. Keunggulan Mesin Virtual ------------------------ Terlepas dari segala kelemahan-kelemahannya, VM memiliki beberapa keunggulan, antara lain: Pertama, dalam hal hal keamanan, VM memiliki perlindungan yang lengkap pada berbagai sistem sumber daya, yaitu dengan meniadakan pembagian resources secara langsung, sehingga tidak ada masalah proteksi dalam VM. Sistem VM adalah kendaraan yang sempurna untuk penelitian dan pengembangan sistem operasi. Dengan VM, jika terdapat suatu perubahan pada satu bagian dari mesin, maka dijamin tidak akan mengubah komponen lainnya. Kedua, dimungkinkan untuk mendefinisikan suatu jaringan dari mesin virtual, di mana tiap-tiap bagian mengirim informasi melalui jaringan komunikasi virtual. Sekali lagi, jaringan dimodelkan setelahkomunikasi fisik jaringan diimplementasikan pada perangkat lunak. Contoh Mesin Virtual -------------------- Contoh penerapan VM saat ini terdapat pada sistem operasi Linux.Mesin virtual saat ini memungkinkan aplikasi Windows untuk berjalanpada komputer yang berbasis Linux. VM juga berjalan pada aplikasi Windows dan sistem operasi Windows. --------------------------------------------------------------------- 8.2 Konsep Bahasa Java Sun Microsystems mendesain bahasa Java, yang pada mulanya dikenal dengan nama Oak. James Gosling, sang pencipta Oak, menciptakannya sebagai bagian dari bahasa C++. Bahasa ini harus cukup kecil agar dapat bertukar informasi dengan cepat di antara jaringan kabel perusahaan dan pertelevisian dan cukup beragam agar dapat digunakan lebih dari satu jaringan kabel. Sun Microsystems lalu merubah nama Oak menjadi Java, kemudian membuatnya tersedia di dalam Internet. Perkenalan dengan Java di Internet ini dimulai pada tahun 1995. Java didesain dengan tujuan utama portabilitas, sesuai dengan konsep write once run anywhere. Jadi, hasil kompilasi bahasa Java bukanlah native code, melainkan bytecode. Bytecode dieksekusi oleh interpreter Java yang juga merupakan Java Virtual Machine. Penjelasan mengenai Java Virtual Machine (JVM) akan dijelaskan pada bab 8.3.
  • Ada beberapa hal yang membedakan Java dengan bahasa pemrograman lain yang populer pada saat ini, yakni: 1. Bersifat portable, artinya program Java dapat dijalankan pada platform yang berbeda tanpa perlu adanya kompilasi ulang. 2. Memiliki garbage collection yang berfungsi untuk mendelokasi memori secara otomatis. 3. Menghilangkan pewarisan ganda, yang merupakan perbaikan dari bahasa C++. 4. Tidak ada penggunaan pointer, artinya bahasa Java tidak membolehkan pengaksesan memori secara langsung. Teknologi Java terdiri dari tiga komponen penting, yakni: 1. Spesifikasi bahasa pemrograman 2. Application Programming Interface (API) 3. Spesifikasi mesin virtual Penjelasan lebih lanjut mengenai komponen Java adalah sebagai berikut. 1. Bahasa Pemrograman Bahasa Java merupakan bahasa pemrograman yang berorientasi pada objek(object- oriented), memiliki arsitektur yang netral (architecture-neutral), dapat didistribusikan, dan mendukung multithread. Objek-objek dalam Java dispesifikasikan ke dalam class; program Java terdiri dari satu atau beberapa class. 01 class Objek1 02 { 03 private int attribut1; 04 private String attribut2; 05 06 public void changeAttribut1() 07 { 08 // melakukan sesuatu terhadap attribut1 harus dengan 09 // method ini. Jadi variabel attribut1 aman di dalam 10 // objeknya, tidak mudah diakses begitu saja... 11 } 12 } 13 14 class Objek2 15 { 16 private int attribut1; 17 private String attribut2; 18 19 public Objek1 objekSatu; 20 21 public void interfensi() 22 { 23 objekSatu.changeAttribut1(); 24 // valid karena akses modifiernya public 25 26 System.out.print( objekSatu.attribut1 ); 27 // invalid karena akses modifiernya private 28 } 29 } [Gambar 8-2. Contoh penggunaan class objek dalam Java]
  • Dari setiap class dalam Java, Java compiler menghasilkan sebuah output berupa berkas bytecode yang bersifat architecture-neutral. Artinya, berkas tersebut akan dapat berjalan pada mesin virtual Java (JVM) manapun. Pada awalnya, Java digunakan untuk pemrograman Internet, karena Java menyediakan sebuah layanan yang disebut dengan applet, yaitu program yang berjalan dalam sebuah web browser dengan akses sumber daya yang terbatas. Java juga menyediakan layanan untuk jaringan dan distributed objects. Java adalah sebuah bahasa yang mendukung multithread, yang berarti sebuah program Java dapat memiliki beberapa thread. Java termasuk sebuah bahasa yang aman. Hal ini sangat penting mengingat program Java dapat berjalan dalam jaringan terdistribusi. Java juga memiliki suatu pengendalian memori dengan menjalankan garbage collection, yaitu suatu fasilitas untuk membebaskan memori dari objek-objek yang sudah tidak dipergunakan lagi dan mengembalikannya kepada sistem. 2. API API merupakan suatu metode yang menggunakan sebuah aplikasi program untuk mengakses sistem operasi dari komputer. API memungkinkan kita untuk memprogram antarmuka pre-constructed sebagai pengganti memprogram device atau bagian dari perangkat lunak secara langsung. API menyediakan sarana bagi para programmer untuk mendesain antarmuka dengan komponen yang disediakan. Hal ini membuat pengembangan dan pendesainan antarmuka menjadi cepat, tanpa harus memiliki pengetahuan secara mendetail tentang device atau perangkat lunak yang digunakan. Sebagai contoh, API dari OpenGL memungkinkan kita untuk membuat efek 3D tanpa perlu mengetahui bagian dalam dari kartu grafis. API dalam Java -------------- Terdiri dari tiga bagian, yaitu: 1. API standar yang dipergunakan untuk aplikasi dan applet dengan layanan bahasa dasar untuk grafik, M/K, utilitas, dan jaringan. 2. API enterprise untuk mendesain aplikasi server dengan layanan database dan aplikasi server-side (dikenal dengan servlet). 3. API untuk device kecil seperti komputer genggam, pager, dan ponsel. 01 import java.util.Date; 02 03 class Tanggal 04 { 05 public void cetak() 06 { 07 Date tanggal = new Date(); 08 // membuat objek baru untuk tanggal 09 10 String cetak1 = tanggal.toString(); 11 12 System.out.println( cetak1 ); 13 // mencetak tanggal hari ini 14 } 15 } [Gambar 8-3. Contoh penggunaan Java API]
  • --------------------------------------------------------------------- 8.3 Konsep Mesin Virtual Java Mesin Virtual Java atau Java Virtual Machine (JVM) terdiri dari sebuah class loader dan Java interpreter yang mengeksekusi architecture-neutral bytecode. Java interpreter merupakan suatu fasilitas penerjemah dalam JVM. Fungsi utamanya adalah untuk membaca isi berkas bytecode (.class) yang dibuat Java compiler saat berkas berada dalam memori, kemudian menerjemahkannya menjadi bahasa mesin lokal. Java interpreter dapat berupa perangkat lunak yang menginterpretasikan bytecode setiap waktu, atau hanya Just-In-Time (JIT), yang mengubah architecture- neutral bytecode menjadi bahasa mesin lokal. Interpreter bisa juga diimplementasikan pada sebuah chip perangkat keras. Instance dari JVM dibentuk ketika aplikasi Java atau applet dijalankan. JVM mulai berjalan saat method main() dipanggil. Pada applet, JVM menciptakan method main() sebelum membuat applet itu sendiri. Java Development Environment terdiri dari sebuah Compile-Time Environment dan Runtime Environment. Compile berfungsi mengubah sourcecode Java menjadi bytecode, sedangkan Runtime merupakan Java Platform untuk sistem Host. [Gambar 8-4. Struktur Mesin Virtual Java] Sumber: http://utenti.lycos.it/yanorel6/2/ch52.htm 8.4 Sistem Operasi Java Kebanyakan dari sistem operasi yang ada dewasa ini dibuat dari kombinasi bahasa C dan bahasa assembly. Hal ini disebabkan karena keuntungan performa serta kemudahan dalam berinteraksi dengan perangkat keras. Kami menyebut ini sebagai sistem operasi tradisional. Namun, akhir-akhir ini banyak usaha yang dilakukan dalam membuat sistem operasi berbasis bahasa pemrogramanan, terutama sistem operasi berbasis bahasa pemrograman Java, di antaranya adalah sistem operasi JavaOS yang telah merilis versi 1.0 dan juga JX. Perbedaan antara keduanya adalah pada fungsionalitas bahasa pemrograman yang digunakan. JavaOS sepenuhnya menggunakan fungsionalitas bahasa Java, sementara JX menggunakan gabungan fungsionalitas dari bahasa Java, C, dan assembly. Sistem Operasi JavaOS --------------------- JavaOS adalah satu-satunya sistem yang mencoba untuk mengimplementasi fungsi sistem operasi dalam bahasa Java secara lengkap. JavaOS mengimplementasi platform Java agar dapat menjalankan aplikasi atau applet yang mengakses fasilitas dari beberapa objek. Selain itu, JavaOS juga mengimplementasikan JVM dan lapisan fungsionalitas untuk windowing, jaringan, dan sistem berkas tanpa membutuhkan dukungan dari sistem operasi lokal. JavaOS mendefinisikan platform seperti halnya CPU, memori, bus, dan perangkat keras lainnya. Platform independen dari sistem operasinya disebut JavaOS runtime, sedangkan bagian platform yang non- independen dari sistem operasinya disebut JavaOS kernel.
  • [Gambar 8-5. Struktur sistem operasi JavaOS] Sumber: http://utenti.lycos.it/yanorel6/2/ch52.htm JavaOS menyediakan lingkungan Java yang standalone. Dengan kata lain, aplikasi yang dikembangkan untuk platform Java yang menggunakan JavaOS dapat berjalan pada perangkat keras tanpa dukungan sistem operasi lokal. Selain itu, aplikasi yang ditulis untuk berjalan pada satu mesin tanpa adanya sistem operasi lokal dapat pula berjalan pada mesin yang memiliki sistem operasi lokal. JavaOS terbagi menjadi dua, yaitu kode platform independen dan platform non- independen.Kode platform non-independen merujuk kepada kernel dan terdiri atas mikrokernel dan JVM. Mikrokernel menyediakan layanan menajemen memori, interupsi dan penganan trap, multithread, DMA, dan fungsi level rendah lainnya. JVM menerjemahkan dan mengeksekusi bytecode Java. Tujuan dari kernel adalah untuk meringkaskan spesifikasi perangkat keras dan menyediakan platform antarmuka yang netral dari sistem operasi. Kernel JavaOS ------------- Kernel JavaOS membutuhkan antarmuka untuk underlying machine dengan JVM. Hal ini memungkinkan kernel untuk menjadi lebih kecil, cepat, dan portabel. Beberapa fungsi yang disediakan oleh kernel di antaranya adalah: 1. Sistem Booting 5. Monitor 9. Debug 2. Exceptions 6. Sistem berkas 3. Thread 7. Timing 4. Manajemen Memori 8. DMA Sedangkan kode platform independen dari JavaOS merujuk pada JavaOS runtime. Runtime sepenuhnya ditulis dalam bahasa Java, yang memungkinkan untuk dijalankan pada platform yang berbeda. Java runtime terdiri dari device driver, dukungan jaringan, sistem grafik, sistem windowing, dan elemen lain dari Java API. Device driver mendukung komunikasi dengan monitor, mouse, keyboard, dan kartu jaringan. Komponen JavaOS Runtime ----------------------- JavaOS runtime terdiri dari fungsi spesifik sistem operasi yang ditulis dalam bahasa Java. Komponen dari JavaOS runtime di antaranya Device Driver, Jaringan TCP/IP, Sistem Grafik, dan Sistem Window.
  • Sistem Operasi JX ----------------- Mayoritas sistem operasi JX ditulis dalam bahasa Java, sementara kernel mikronya ditulis dalam bahasa C dan assembly yang mengandung fungsi yang tidak terdapat di Java. Struktur utama dari JX adalah tiap kode Java diorganisasikan sebagai komponen, di mana kode di-load langsung ke domain dan diterjemahkan ke native code. Domain meng-encapsulate objek dan thread. Komunikasi antara domain ditangani menggunakan portal. Berikut penjelasan lebih lanjut mengenai arsitektur sistem operasi JX: 1. Domain; yaitu unit proteksi dan manajemen sumber daya di mana semua domain kecuali domain zero mengandung 100% kode bahasa Java. 2. Portal; merupakan dasar mekanisme komunikasi inter-domain.Cara kerjanya mirip dengan Java RMI yang membuat programmer mudah menggunakannya. 3. Objek memori, merupakan abstraksi dari representasi area memori yang diakses dengan method invocations. 4. Komponen; tiap kode java yang di-load ke suatu domain diatur pada komponen. Suatu komponen mengandung class, antarmuka, dan tambahan informasi. 5. Manajemen memori; proteksi memori berbasiskan bahasa type-safe. 6. Verifier dan Translator; merupakan bagian penting dari sistem JX. Mekanismenya, semua kode diverifikasi sebelum diterjemahkan ke dalam bentuk native code dan dieksekusi. 7. Device driver; semua device driver sistem JX ditulis dalam bahasa Java. 8. Penjadualan; sistem JX menggunakan pendekatan di mana penjadualan diimplementasikan di luar kernel mikro. 9. Locking; terdapat kernel-level locking, domain-level locking, dan inter- domain locking. Kelemahan sistem operasi berbasis bahasa pemrograman ---------------------------------------------------- Salah satu kesulitan dalam mendesain sistem berbasis bahasa pemrograman adalah menyangkut masalah proteksi, khususnya proteksi memori. Sistem operasi tradisional menyandarkan pada fitur perangkat keras untuk menyediakan proteksi memori. Sistem berbasis bahasa pemrograman sendiri memiliki ketergantungan pada fitur type-safety dari bahasa pemrograman tersebut untuk mengimplementasikan proteksi memori. Hasilnya, sistem berbasis bahasa pemrograman memerlukan perangkat keras yang mampu menutupi kekurangan dalam hal fitur proteksi memori. --------------------------------------------------------------------- 8.5 Rangkuman Konsep mesin virtual sangat baik, namun cukup sulit untuk diimplementasikan, karena mesin virtual harus mampu berjalan pada dua keadaan sekaligus, yaitu virtual user mode dan virtual monitor mode. Mesin virtual juga memiliki keunggulan, yaitu proteksi sistem yang sangat cocok untuk riset dan pengembangan sistem operasi.
  • Java didesain dengan tujuan utama adalah portabilitas. Dengan konsep write once run anywhere, maka hasil kompilasi bahasa Java yang berupa bytecode dapat dijalankan pada platform yang berbeda. Teknologi Java terdiri dari tiga komponen penting, yakni spesifikasi bahasa pemrograman, Application Programming Interface (API) dan spesifikasi mesin virtual. Bahasa Java mendukung paradigma berorientasi objek serta dilengkapi juga dengan library API yang sangat lengkap. Mesin virtual Java atau Java Virtual Machine (JVM) terdiri dari sebuah class loader dan Java interpreter yang mengeksekusi architecture-neutral bytecode. JavaOS dibangun dari kombinasi native code dan Java code, di mana platformnya independen. Sedangkan JX merupakan sistem operasi di mana setiap kode Java diorganisasikan sebagai komponen. --------------------------------------------------------------------- 8.6 Latihan 1. Mengapa mesin virtual sulit untuk diimplementasikan? 2. Sebutkan 2 keunggulan bahasa Java! 3. Sebutkan 3 komponen penting dalam teknologi Java! 4. Jelaskan secara singkat fungsi dari API pada bahasa Java! 5. Jelaskan tugas class loader pada mesin virtual Java! 6. Sebutkan beberapa fungsi yang disediakan oleh kernel JavaOS! 7. Jelaskan mekanisme arsitektur sistem operasi JX! 8. Apakah kelemahan dari desain sistem operasi yang berbasis bahasa pemrograman? Jelaskan secara singkat! --------------------------------------------------------------------- 8.7 Rujukan http://utenti.lycos.it/yanorel6/2/ch52.htm http://casl.csa.iisc.ernet.in/OperatingSystems/JavaOS/ http://www.javasoft.com/products/javaos/javaos.white.html http://www.jxos.org/publications/jx-usenix.pdf --------------------------------------------------------------------- 8.8 Bibliografi [Silberschatz2004] Avi Silberschatz, Peter Galvin, and Greg Gagne, 2004, Operating System Concepts with Java, 6th Edition, John Wiley & Sons. [Venners1998] Bill Venners, 1998, Inside the Java Virtual Machine, McGraw-Hill. ---------------------------------------------------------------------
  • JavaOS Why JavaOS? • JavaOS Features • The JavaOS Architecture • The JavaOS Kernel • o System Booting o Memory Management o Interrupt and Exception Handling o Timer Management o Direct Memory Access Control o Multithreading Support o File System Access o Native Code Interface o Debugging Support JavaOS Runtime Components • o Device Drivers o TCP/IP Networking o Graphics System o Windowing System o Other API Classes HotJava and HotJava Views • Summary • One of the most exciting new products released by JavaSoft is the JavaOS version 1.0. JavaOS promises to be the operating system of choice for network computers (NCs), Personal Digital Assistants (PDAs), and commercial electronics devices. This chapter looks at JavaOS, describes its architecture, and examines its features. Why JavaOS? With Java supported on Windows, Macintosh, Linux, and UNIX platforms, why would JavaSoft create JavaOS? Rather than porting an existing operating system to new hardware and running Java on top of that operating system, the engineers at JavaSoft and Sun decided to create JavaOS as a small, memory-efficient, fast, and
  • highly portable operating system (OS) that provides direct support for the Java runtime environment, windowing system, networking capabilities, and other features of the Java API. The goal of JavaOS is to make Java available on low-powered and low-memory devices, such as NCs and PDAs. JavaOS 1.0 is currently available for the Intel X86, Sun SPARC, and StrongARM hardware platforms. Of course, JavaOS will also run on the JavaChip family of processors (picoJava, microJava, and UltraJava). These processors are targeted to a range of products including consumer electronics devices (Web phones and PDAs), network computers, and network servers. JavaOS Features Besides providing native Java support, JavaOS has a number of features that make it an ideal operating system for intranet applications. Its small memory footprint and efficient use of processing resources make it an ideal OS for running thin-client applications on network computers. Four megabytes of RAM are sufficient to run JavaOS, HotJava, and other common applications. JavaOS is being ported to low-end x86 machines, extending their lives as network computers. It can be burnt into ROM, allowing it to run on PDAs, hand-held PCs, and consumer electronics devices. The integrated networking support of JavaOS provides the TCP/IP communication capabilities required in an intranet environment. Its remote boot and network login capabilities enable Java applications and support files to be installed on and managed from a central server. This allows system administrators to automatically upgrade client software across the enterprise and to back up client data at periodic intervals. The central management of JavaOS clients enables zero client administration and facilitates enterprise-wide software distribution and management. The JavaOS windowing system supports the HotJava and HotJava Views user environments, providing users with a full graphical user interface and the capability to browse Web pages, run Java applets, and exchange email. With JavaOS, users are able to log into a network, from any location, and instantly access their personal workspaces. Finally, because Java supports the complete Java API, any pure Java application will run on JavaOS. This means that new Java applications, such as the Star Office suite, will run on JavaOS as-is. It also means that even small Java platforms, such as PDAs, will be able to take advantage of the mulithreading, memory management, graphics, and networking capabilities of the Java API. The JavaOS Architecture JavaOS is organized into platform-dependent and platform-independent code. The platform-dependent code is referred to as the kernel and consists of the microkernel and Java Virtual Machine (JVM). The microkernel provides memory management, interrupt and trap handling, multithreading, DMA, and other low-level operating system functions. The JVM interprets and executes Java byte codes. The purpose of the kernel is to abstract hardware-specific details and provide a platform-neutral interface for the rest of JavaOS.
  • The platform-independent code of JavaOS is referred to as the Java runtime. The runtime is written in Java, enabling it to be easily ported and upgraded. It consists of device drivers, networking support, a graphics system, a windowing system, and other elements of the Java API. The device drivers support communication with a display monitor, keyboard, mouse, and network interface card. The networking support classes implement the TCP/IP protocol suite using the network device driver. The graphics and windowing systems provide and implement the Abstract Windowing Toolkit (AWT). Other layers support stream I/O and the remaining elements of the Java API. Figure 52.1 provides an overview of the JavaOS architecture. JavaOS is a layered operating system that may be tailored for a particular application environment. The layers are functionally independent and may be added or omitted to support the needs of the operating environment. For example, a network computer would utilize all layers of JavaOS and add the HotJava browser and HotJava Views application environments. A consumer electronics device, on the other hand, may only require a limited number of JavaOS layers to run custom application software. FIGURE 52.1. The JavaOS architecture. The JavaOS Kernel Because the JavaOS runtime provides many operating system elements, such as device drivers, file I/O, and windowing and networking support, the JavaOS kernel needs only to provide an interface with the underlying hardware and implement the JVM. This enables the kernel to be small, fast, and portable. The following sections cover the functions performed by the kernel. System Booting Since JavaOS is intended for a number of different hardware platforms, it must be capable of booting from a variety of sources including disks, ROM, and network devices. The kernel booting software need not provide all booting capabilities on all hardware platforms, but may be individually tailored for a specific hardware implementation. Memory Management Different microprocessors provide varying levels of memory management features to allow memory to be allocated and made available to executing programs. Some microprocessors convert real memory addresses into virtual addresses in order to simplify memory access. Others implement memory access controls that prevent conflicts between programs and enhance system security and integrity. The objective of the memory management function of the JavaOS kernel is to remove these hardware details from the concern of the runtime software by providing a common interface for the allocation and deallocation of memory resources. It uses the underlying hardware memory management capabilities to translate physical memory addresses into virtual addresses and manage the allocation of virtual memory units. The kernel memory management software does not require physical-to-virtual address
  • translation hardware. Instead, it utilizes whatever capabilities are provided by the hardware platform and makes up for any shortcomings using software translation. JavaOS operates in a single virtual address space that it shares with the runtime and application programs. This address space is never seen outside of the JVM, because the Java memory model does not provide access to memory pointers. Interrupt and Exception Handling External devices, such as keyboards, mice, disks, and I/O cards, communicate with an operating system by generating interrupts that are handled and processed by the operating system. Software interrupts, referred to as traps, are used in a similar manner by application programs to request services of the OS. Exceptions consist of traps and other OS calls that are used to signal the occurrence of an error or anomalous condition. The interrupt, trap, and exception processing components of the JavaOS kernel utilize the underlying hardware's interrupt vectoring capabilities to assign interrupts, traps, and exceptions to the appropriate handling routines and device drivers. Timer Management The system clock and timer devices generate periodic interrupts to the operating system that are used to keep track of the current time, perform thread scheduling, control the operation of device drivers, and provide API timer support. The JavaOS timer management software utilizes the platform-dependent clock and timer hardware to provide these functions. Direct Memory Access Control Direct memory access (DMA) is used by high-speed devices, such as disks, to quickly move information in and out of RAM. The DMA support software of the kernel uses the hardware DMA capabilities to communicate with system devices that use DMA. This software provides a hardware-independent DMA interface to device drivers. Multithreading Support The multithreading support function of the kernel manages the memory used by executable threads, saves the current context of a thread, schedules the next thread to be executed, and performs context-switching. The multithreading support function interfaces with the memory management, timer management, and other kernel functions in order to implement multithreading capabilities. File System Access Low-level kernel file system support is required in environments, such as a network boot environment, where the kernel must interface with foreign file systems prior to the loading of the device drivers of the runtime system. Native Code Interface
  • The kernel may provide the capability to interface with native machine code when that code is required to implement OS functions. An example would be an interface to native code that would drive an advanced video card. Debugging Support Certain types of software debugging require the capability to step between machine or byte code instructions under hardware control. Many microprocessors support a special debugging mode of execution. The kernel debugging support software utilizes native debugging facilities to accommodate application-level debugging requirements. The JVM The previously discussed kernel components focus on the utilization of the underlying hardware capabilities to support the needs of the JavaOS runtime. The JVM takes .class files in the Java byte code format and executes them using the machine code instructions of the underlying microprocessor. In order to do this, the JVM must synchronize and control the operation of the rest of the kernel functions. It utilizes the memory management function to control the allocation of memory resources in the form of Java objects, the interrupt handling, DMA, and timer management functions to support Java device drivers, the multithreading and timer management functions to support Java threads, and so on. The JVM is the nucleus of the Java kernel. The other kernel functions provide support to the JavaOS runtime under the direction and control of the JVM. JavaOS Runtime Components The JavaOS runtime consists of operating system-specific functions that are written in Java. The JavaOS kernel provides a platform-independent JVM interface by removing hardware-specific characteristics from consideration. The runtime provides the platform-independent resources of the Java API to application programs. The components of the Java runtime are covered in the following sections. Device Drivers Device drivers are used to enable communication between the operating system and external devices such as display monitors, keyboards, mice, and network interface cards. The availability of device drivers is a critical factor in determining the success or failure of an operating system. How many times have you heard, quot;I couldn't get Windows NT to work with my sound card,quot; or quot;The Macintosh doesn't have a driver for that scannerquot;? The popularity of an operating system and the availability of device drivers are so closely related that it's hard to determine which one causes the other. Operating systems are popular because they support a variety of devices. Device drivers were written for popular operating systems long before they were written for not-so-popular operating systems. In JavaOS, all device drivers are written in Java (with two minor exceptions, as discussed in the following note). This has advantages and disadvantages. The primary advantage is that device drivers are highly portable. Once a device driver is written
  • for JavaOS, it is highly likely that the device driver will run across all JavaOS hardware implementations. NOTE: Device drivers require the capability to directly address specific physical memory addresses and to handle device interrupts. The software to implement these capabilities is implemented in C language code and made available via the Memory and Interrupt classes. The Memory class provides direct access to memory addresses. The Interrupt class supports interrupt handling. These classes can only be accessed by registered device drivers. The disadvantage of using only Java device drivers is that no existing device drivers will work with JavaOS. All device drivers have to be written from scratch. Fortunately, JavaOS is so popular that many device drivers are being written by hardware vendors and third-party software developers. TCP/IP Networking One of the strongest features of JavaOS is its support for TCP/IP networking. In fact, JavaOS provides more comprehensive TCP/IP networking support than Windows NT. JavaOS supports the basic IP, TCP, and UDP protocols you learned about in Part VIII, quot;Network Programming.quot; It also supports the Internet Control Message Protocol used by the Ping command and network management functions, the Dynamic Host Configuration Protocol (DHCP) used to dynamically assign IP addresses, the Reverse Address Resolution Protocol (RARP) used to determine a host's address, the Domain Name Service (DNS) for hostname-to-IP address translation, and the Network Information Service (NIS) to support network login. It also supports the Network File System (NFS) protocol to share files across a network and the Simple Network Management Protocol (SNMP) to manage network clients and servers. Such extensive networking support alone is reason enough to dump your old desktop OS and install JavaOS. Graphics System The graphics system of the JavaOS runtime consists of the basic graphics functions required to manage a display monitor and provide the foundation for an AWT implementation. These functions provide the capability to draw and fill geometric objects, render fonts, and control and display cursors. For performance reasons, some of these functions require direct access to physical memory locations and are implemented as native C language methods. Windowing System The windowing system of the JavaOS runtime is none other than the AWT. A special Tiny AWT library is used to implement GUI components. The Tiny AWT does not rely on platform-dependent peer classes of the GUI components. Other API Classes
  • The Java runtime provides full support for all classes and interfaces of the Java API. This includes stream input and output, applets, math functions, and all of the other goodies found in the core Java API classes. HotJava and HotJava Views Although HotJava and HotJava Views are not part of JavaOS, they are a welcome addition to any Java system and provide the graphical desktop environment for running user applications. HotJava is a full-featured Web browser, written entirely in Java. It supports HTML 3.2, FTP downloading, email, and, of course, the execution of Java applets. HotJava Views is a user interface environment referred to by JavaSoft as a webtop. It provides pushbutton access to email, calendaring, Web browsing, and other networked applications. HotJava Views was developed to provide a user interface for network computer users. Summary In this chapter, you examined the software architecture of JavaOS and looked at its main features. You also learned about the HotJava browser and the HotJava Views user environment. In the next chapter, you'll learn how to interface Java code with code written in other languages. --------------------------------------------------------------------- 9.10 Sistem GNU/Linux, rangkuman Kernel Linux terdistribusi di bawah Lisensi Publik Umum GNU (GPL), di mana peraturannya disusun oleh Free Software Foundation (FSF). Implikasi utama terhadap peraturan ini adalah bahwa siapa saja boleh menggunakan Linux atau membuat modifikasi, namun tidak boleh membuatnya menjadi milik sendiri. Perkembangan sistem operasi Linux sangat cepat karena didukung pengembang di seluruh dunia yang akan selalu memperbaiki segala fiturnya. Di negara-negara berkembang, Linux mengalami kemajuan yang sangat pesat karena dengan menggunakan Linux mereka dapat menghemat anggaran. Linux juga telah diterapkan pada supercomputer. Prinsip rancangan Linux merujuk pada implementasi agar kompatibel dengan UNIX yang merupakan sistem multiuser dan multitasking. Sistem Linux terdiri dari tiga bagian penting, yaitu kernel, perpustakaan, dan utilitas. Kernel merupakan inti dari sistem operasi Linux. Perpustakaan sistem Linux menyediakan berbagai fungsi yang diperlukan untuk menjalankan aplikasi UNIX atau POSIX. Modul kernel Linux adalah bagian dari kernel Linux yang dapat dikompilasi, dipanggil dan dihapus secara terpisah dari bagian kernel lainnya. Terdapat tiga komponen yang menunjang kernel Linux, di antaranya adalah Manajemen Modul Kernel Linux, Registrasi Driver, dan Resolusi Konflik. --------------------------------------------------------------------- 16.9 Algoritma Penjadualan II, rangkuman Sistem hard real-time biasa digunakan menyelesaikan critical task
  • dengan jaminan waktu tertentu. Jika kebutuhan waktu tidak terpenuhi, maka aplikasi akan gagal. Sistem operasi menggunakan mekanisme resource reservation untuk menerima atau menolak suatu permintaan proses. Sistem soft real-time memiliki kelonggaran waktu dibandingkan sistem hard real-time. Sistem soft real-time dapat mengakibatkan delay yang lebih lama atau dapat menyebabkan terjadinya starvation. --------------------------------------------------------------------- 17.8 Manajemen Proses Linux, rangkuman Kernel Linux mengawasi dan mengatur proses berdasarkan nomor process identification number (PID), sedangkan informasi tentang setiap proses disimpan pada deskriptor proses. Deskriptor proses merupakan struktur data yang memiliki beberapa status, yaitu : TASK_RUNNING, TASK_INTERRUPTIBLE, TASK_UNINTERRUPTIBLE, TASK_STOPPED, dan TASK_ZOMBIE. Linux menyediakan dua system call, yaitu fork dan clone. Fork memiliki fungsi untuk menduplikasi proses di mana proses anak yang dihasilkan bersifat independen. Sedangkan fungsi clone, selain menduplikasi dari proses induk, juga mengizinkan terjadinya proses berbagi ruang alamat antara proses anak dengan proses induk. Sinkronisasi kernel Linux dilakukan dengan dua solusi, yaitu : 1. Dengan membuat normal kernel yang bersifat code nonpreemptible. Akan muncul salah satu dari tiga aksi, yaitu : interupsi, page fault, atau kernel code memanggil penjadualannya sendiri. 2. Dengan meniadakan interupsi pada saat critical section muncul. Penjadualan proses Linux dilakukan dengan menggunakan teknik prioritas, sebuah alogritma yang berdasarkan pada kupon, dengan aturan bahwa setiap proses akan memiliki kupon, di mana pada suatu saat kupon akan habis dan mengakibatkan tertundanya proses tersebut. --------------------------------------------------------------------- 44.11 Subsistem M/K Kernel, rangkuman Subsistem kernel M/K menyediakan layanan yang berhubungan langsung dengan perangkat keras. Layanan Penjadualan M/K mengurutkan antrian permintaan pada tiap perangkat dengan tujuan untuk meningkatkan efisiensi dari sistem dan waktu respon rata-rata yang harus dialami oleh aplikasi. Ada tiga alasan melakukan layanan Buffering, yaitu menyangkut perbedaan kecepatan produsen-konsumen, perbedaan ukuran transfer data dan dukungan copy semantics untuk aplikasi M/K. Fungsi buffering dan caching memiliki perbedaan dalam hal tujuan. Caching menyimpan salinan data asli pada area memori dengan tujuan agar bisa diakses lebih cepat, sedangkan buffering menyalin data asli agar dapat menyimpan satu-satunya informasi data. Subsistem M/K mengkoordinasi kumpulan-kumpulan sevice yang banyak sekali, yang tersedia dari aplikasi atau bagian lain dari kernel. Penanganan permintaan M/K dilakukan dengan suatu mekanisme yang
  • dideskripsikan sebagai sebuah life cycle. Layanan I/O Streams menggunakan suatu mekanisme pengiriman data secara bertahap dan terus menerus melalui suatu aliran data dari piranti ke proses. !quot; # 1 .9 .? (% ? @ &' '/ 1 ( - ! ? % *E ? % = *quot; E *E
  • 0E *E# F ) - ,E . ( - 1 $ 9?) ) = - quot; # = quot;* 0 E# 1 ' ) 1 quot; ) # ?( ) 8? ) % $ ( % 1 1
  • 1