A.
NON-PREEMPTIVE
Penjadwalan Non-preemptive adalah Salah satu jenis penjadwalan dimana
sistem operasi tidak pernah melakukan context switch dari proses yang
sedang berjalan ke proses yang lain. Dengan kata lain, proses yang sedang
berjalan tidak bisa di- interupt.
Jenis-jenis
algoritma Non-preemptive:
1. First In First Out (FIFO)
FIFO adalah Penjadwalan paling sederhana yaitu Prose yang diberi
jatah waktu pemproses berdasarkan waktu kedatangan dimana waktu pemrosesan
diurutkan berdasarkan waktu kedatangan dari proses tersebut. Saat mendapatkan waktu
untuk melakukan pemprosesan, suatu proses akan dijalankan sampai selesai.
Setelah proses pertama selesai maka akan dilakukan proses yang dating diurutan
ke dua, dan berlanjut keproses selanjutnya. FIFO (first in first out) memiliki
pengertian Masuk Pertama, Keluar Pertama, yang abstak dalam cara mengatur dan
manipulasi data yang relatif terhadap waktu dan prioritas. Ungkapan ini
menjelaskan prinsip dari teknik pemrosesan atau melayani permintaan
bertentangan dengan memesan proses pertama datang, pertama-dilayani (FCFS)
perilaku: apa yang masuk pertama adalah Ketika lift mencapai tujuan, yang terakhir
untuk mendapatkan orang harus pertama untuk turun.
Pada saat proses mendapat jatah waktu pemroses, proses dijalankan sampai selesai.Penilian
penjadwalan ini berdasarkan kriteria optimasi :
Ø Adil
Adil dalam
arti resmi (proses yang datang duluan akan dilayani lebih dulu), tapidinyatakan
tidak adil karena job-job yang perlu waktu lama membuat job-jobpendek menunggu.
Job-job yang tidak penting dapat membuat job-job pentingmenunggu lama.
Ø Efisiensi
Sangat
efisien.
Ø Waktu tanggap
Sangat
jelek, tidak cocok untuk sistem interaktif apalagi untuk sistem waktu nyata.
Ø Turn around time
Jelek.
Ø Throughtput
Jelek.
FIFO jarang digunakan secara mandiri, tetapi dikombinasikan dengan skema
lain,misalnya : Keputusan berdasarkan prioritas proses. Untuk proses-pross berprioritassama
diputuskan berdasarkan FIFO.
Penjadwalan
ini :
a. Baik untuk
sistem batch yang sangat jarang berinteraksi dengan pemakai.Contoh : aplikasi
analisis numerik, maupun pembuatan
tabel.
b. Sangat tidak
baik (tidak berguna) untuk sistem interaktif, karena tidak memberiwaktu tanggap
yang baik.
c. Tidak dapat
digunakan untuk sistem waktu nyata (real-time applications)
Contoh FIFO
2.
Shortest Job
First (SJF)
Penjadwalan ini mengasumsikan waktu berjalannya proses sampai selesai telah
diketahui sebelumnya. Mekanismenya adalah menjadwalkan proses dengan waktu
jalan terpendek lebih dulu sampai selesai, sehingga memberikan efisiensi yang
tinggi dan turn around time rendah dan penjadwalannya tak berprioritas. Karena
SJF selalu memperhatikan rata-rata waktu respon terkecil, maka sangat baik
untuk proses interaktif. Umumnya proses interaktif memiliki pola, yaitu
menunggu perintah, menjalankan perintah, menunggu perintah dan menjalankan
perintah, begitu seterusnya. Masalah yang muncul adalah tidak mengetahui ukuran
job saat job masuk. Untuk mengetahui ukuran job adalah dengan membuat estimasi
berdasarkan kelakukan sebelumnya. Prosesnya tidak datang bersamaan, sehingga
penetapannya harus dinamis.
Contoh
:Terdapat empat proses (job) yaitu A,B,C,D dengan waktu jalannya
masing-masingadalah 8,4,4 dan 4 menit. Apabila proses-proses tersebut
dijalankan, maka turnaround time untuk A adalah 8 menit, untuk B adalah 12,
untuk C adalah 16 danuntuk D adalah 20.
Untuk menghitung rata-rata turn around time seluruh proses adalah dengan
menggunakan rumus :
( 4a + 3b +
2c + 1d ) / 4
Dengan
menggunakan rumus, maka dapat dihitung turn around time-nya sebagaiberikut
= ( 4a + 3b + 2c + 1d ) / 4= ( 4x8 + 3x4 + 2x4 + 1x4 ) / 4= ( 32 + 12 + 8 + 4 ) / 4= 56 / 4= 14 menit
Apabila
keempat proses tersebut menggunakan penjadwalan shortest job fisrt , maka turn
around time untuk B adalah 4, untuk C adalah 8, untuk D adalah 12 dan untuk A
adalah 20, sehingga rata-rata turn around timenya adalahsebagai berikut :
= ( 4a + 3b +
2c + 1d ) / 4= ( 4x4 + 3x4 + 2x4 + 1x8 ) / 4= ( 16 +
12 + 8 + 8 ) / 4= 44 / 4= 11 menit
Tidak
memperhatikan
SJF Memperhatikan SJF
Posisi
: a b
c d
a b c
d
Priority : 4
3 2 1
4 3 2
1
Job :
A B C
D A B
C D A
---------------------------------------------------------------------------------------------------
: 8 : 4
: 4 : 4 :
: 4 : 4 : 4
: 8 :
----------------------------------------------------------------------------------------------------
(a)
(b)
Jelas bahwa a memberikan nilai
kontribusi yang besar, kemudian b, c dan d. KarenaSJF selalu memperhatikan
rata-rata waktu respon terkecil, maka sangat baik untukproses interaktif.
Umumnya proses interaktif memiliki pola, yaitu menungguperintah, menjalankan
perintah, menunggu perintah dan menjalankan perintah,begitu seterusnya.Masalah
yang muncul adalah :· Tidak mengetahui ukuran job saat job masuk.Untuk
mengetahui ukuran job adalah dengan membuat estimasi berdasarkankelakukan
sebelumnya.· Proses yang tidak datang bersamaan, sehingga penetapannya harus
dinamis. Penjadwalan ini jarang digunakan, karena merupakan kajian teoritis
untukpembandingan turn around time.
SJF (Shortest – Job – First) adalah
Penggabungan setiap proses merupakan panjang dari brust CPU berikutnya. Panjang
tersebut digunakan untuk penjadwalan proses pada waktu terpendek.
Terdapat 2 skema
·
Nonpreemptive (harus diselesaikan)
Cpu hanya
sekali diberikan pda suatu proses. maka proses tsb tetap memakai cpu hingga
proses tsb melepaskannya.
·
Preemptive (bisa berhenti di tengah jalan)
* Example
Process | Arrival Time | Burst Time
P1 0.0 7
P3 4.0 1
P4 5.0 4
**** SJF (non-preemptive) ****
|===========|===|=====|=====|
0 7
8 12 16
P1 p3
p2 p4
* Waiting time
P1 = 0
P3 = 7 – 4
= 3 (dilihat arrival time)
P2 = 8 – 2
= 6 (dieksekusi mulai waktu ke-8 tapi datang
pada waktu ke-2)
P4 = 12 – 5
= 7 (dieksekusi mulai waktu ke-12 tapi datang
waktu ke-5)
* Average waiting time
0 + 6 + 3 + 7 / 4 = 16/4
= 4
**** SJF (Preemptive) ****
|====|====|===|=====|=========|=========|
0 2 4 5 7 11 16
p1 p2 p3 p2 p4 p1
pada waktu 0 P1 dieksekusi, burst time = 7
pada waktu 2 P2 datang, burst time 4; P1 masih sisa 5
>> di run yg kecil dulu (P2)
pada waktu 4 P3 datang, burst time 1; P2 masih sisa 2
>> di run yg kecil dulu (P3)
* waiting time
P1 = 0 + 9 (9 berasal P1 di run 11 datang 2)
= 9
P2 = 0 + 1 (1 berasal P2 di run 5 datang 4)
= 1
P3 = 0 (datang wktu 4 dieksekusi
waktu 4
3.
Highest
Ratio Next (HRN)
Merupakan
strategi penjadwalan dengan prioritas proses tidak hanya berdasarkan fungsi
waktu layanan tetapi juga jumlah waktu tunggu proses. Begitu proses mendapat
jatah pemproses, proses berjalan sampai selesai.
Penjadwalan
HRN merupakan:
- Penjadwalan non-preemptive
- Penjadwalan berprioritas dinamis
Penjadwalan ini juga untuk mengkoreksi kelemahan SJF. HRN adalah strategi
penjadwalan nonpreemptive dengan prioritas proses tidak hanya merupakan fungsi
dari waktu layanan tapi juga jumlah waktu tunggu proses. Prioritas dinamis HRN
dihitung berdasarkan rumus:Prioritas =
(Waktu tunggu + waktu layanan) / waktu layanan. Karena waktu layanan muncul
sebagai pembagi maka proses yang lebih pendek mempunyai prioritas yang lebih
baik. Karena waktu tunggu sebagai pembilang maka proses yang telah menunggu
lebih lama juga mempunya kesempatan lebih bagus untuk memperoleh layanan
pemrosesan. Disebut HRN (High Response Next) karena (waktu tanggap adalah waktu
tunggu + waktu layanan). Ketentuan HRN berarti agar memperoleh waktu tanggap
tertinggi yang harus dilayani.
4.
Multiple
Feedback Queues (MFQ)
Algoritma
ini mirip sekali dengan algoritma multilevel queue. Perbedaannya
ialah algoritma ini mengizinkan proses untuk pindah antrian. Jika suatu proses
menyita CPU terlalu lama, maka proses itu akan dipindahkan ke antrian yang
lebih rendah. Hal ini menguntungkan proses interaksi karena proses ini hanya
memakai waktu CPU yang sedikit. Demikian pula dengan proses yang menunggu
terlalu lama. Proses ini akan dinaikkan tingkatannya. Biasanya prioritas
tertinggi diberikan kepada proses dengan CPU burst terkecil, dengan
begitu CPU akan terutilisasi penuh dan M/K dapat terus sibuk. Semakin rendah
tingkatannya, panjang CPU burst proses juga semakin besar.
Algoritma
ini didefinisikan melalui beberapa parameter, antara lain:
- Jumlah antrian.
- Algoritma penjadwalan tiap antrian.
- Kapan menaikkan proses ke antrian yang lebih
tinggi.
- Kapan menurunkan proses ke antrian yang lebih
rendah.
- Antrian mana yang akan dimasuki proses yang
membutuhkan.
Dengan
pendefinisian seperti tadi membuat algoritma ini sering dipakai, karena
algoritma ini mudah dikonfigurasi ulang supaya cocok dengan sistem. Tapi untuk
mengatahui mana penjadwal terbaik, kita harus mengetahui nilai parameter
tersebut.
Multilevel
feedback queue adalah salah satu algoritma yang berdasar pada
algoritma multilevel queue. Perbedaan mendasar yang
membedakan multilevel feedback queue dengan multilevel
queue biasa adalah terletak pada adanya kemungkinan suatu proses berpindah
dari satu antrian ke antrian lainnya, entah dengan prioritas yang lebih rendah
ataupun lebih tinggi, misalnya pada contoh berikut.
- Semua proses yang baru datang akan diletakkan
pada queue 0 ( quantum= 8 ms).
- Jika suatu proses tidak dapat diselesaikan dalam
8 ms, maka proses tersebut akan dihentikan dan dipindahkan ke queue
1 ( quantum= 16 ms).
- Queue 1 hanya akan dikerjakan jika
tidak ada lagi proses di queue 0, dan jika suatu proses di queue
1 tidak selesai dalam 16 ms, maka proses tersebut akan dipindahkan ke
queue 2.
- Queue 2 akan dikerjakan bila queue 0
dan 1 kosong, dan akan berjalan dengan algoritma FCFS.
Disini
terlihat bahwa ada kemungkinan terjadinya perpindahan proses antar queue,
dalam hal ini ditentukan oleh time quantum, namun dalam prakteknya
penerapan algoritma multilevel feedback queue akan diterapkan
dengan mendefinisikan terlebih dahulu parameter-parameternya, yaitu:
- Jumlah antrian.
- Algoritma internal tiap queue.
- Aturan sebuah proses naik ke antrian yang lebih
tinggi.
- Aturan sebuah proses turun ke antrian yang lebih
rendah.
- Antrian yang akan dimasuki tiap proses yang baru
datang.
Contoh:
Terdapat
tiga antrian; Q1=10 ms, FCFS Q2=40 ms, FCFS Q3=FCFS proses yang masuk, masuk ke
antrian Q1. Jika dalam 10 ms tidak selesai, maka proses tersebut dipindahkan ke
Q2. Jika dalam 40 ms tidak selesai, maka dipindahkan lagi ke Q3. Berdasarkan
hal-hal di atas maka algoritma ini dapat digunakan secara fleksibel dan
diterapkan sesuai dengan kebutuhan sistem. Pada zaman sekarang ini
algoritma multilevel feedback queue adalah salah satu yang paling
banyak digunakan.
B.
PREEMPTIVE
Penjadwalan
Preemptive adalah algoritma
Preemptive digerakkan oleh konsep diprioritaskan komputasi. Jika proses saat
ini menggunakan prosesor baru dan proses dengan prioritas yang lebih tinggi
masuk, yang siap daftar, proses pada prosesor harus dihapus dan kembali ke
daftar siap sampai sekali lagi adalah yang tertinggi-prioritas dalam proses
sistem.selain scheduling dapat dilakukan pada dua event di atas, maka
scheduling dapat terjadi jika proses sedang run (interrupt karena waktu quantum
/ time slice habis) dan diganti proses lain, atau status dari wait menjadi
ready (misalkan proses prioritas lebih tinggi, dapat langsung mendapatkan jatah
CPU setelah selesai I/O request).
Preemptive mempunyai arti kemampuan sistem operasi untuk
memberhentikan sementara proses yang sedang berjalan untuk memberi ruang kepada
proses yang prioritasnya lebih tinggi. Penjadwalan Preemptive
memungkinkan sistem untuk lebih bisa menjamin bahwa setiap proses mendapat
sebuah slice waktu operasi. Dan juga membuat sistem lebih cepat merespon
terhadap event dari luar (contohnya seperti ada data yang masuk) yang
membutuhkan reaksi cepat dari satu atau beberapa proses. Membuat penjadwalan
yang Preemptive mempunyai keuntungan yaitu sistem lebih responsif
daripada sistem yang memakai penjadwalan Non Preemptive.
Dalam waktu-waktu tertentu, proses
dapat dikelompokkan ke dalam dua kategori: proses yang memiliki Burst
M/K yang sangat lama disebut I/O Bound, dan proses yang memiliki Burst
CPU yang sangat lama disebut CPU Bound. Terkadang juga suatu sistem
mengalami kondisi yang disebut busywait, yaitu saat dimana sistem
menunggu request input(seperti disk, keyboard, atau
jaringan). Saat busywait tersebut, proses tidak melakukan sesuatu yang
produktif, tetapi tetap memakan resource dari CPU. Dengan penjadwalan Preemptive,
hal tersebut dapat dihindari.
Dengan kata lain, penjadwalan Preemptive
melibatkan mekanisme interupsi yang menyela proses yang sedang berjalan dan
memaksa sistem untuk menentukan proses mana yang akan dieksekusi selanjutnya.
Jenis- jenis algoritna Preemtive:
1.
Round Robin
(RR)
Penjadwalan
Round-Robin merupakan:
- Penjadwalan preemptive, namun proses tidak
di-preempt secara langsung oleh proses lain namun oleh penjadwal
berdasarkan lama waktu berjalannya suatu proses maka penjadwalan ini
disebut preempt-by-time.
- Penjadwalan tanpa prioritas.
Semua proses
dianggap penting dan diberi sejumlah waktu pemroses yang disebut kwanta
(quantum) atau time-slice tempat proses itu berkalan. Proses berjalannya selama
1 kwanta, kemudian penjadwal akan mengalihkan kepada proses berikutnya, juga
untuk berjalan satu kwanta, begitu seterusnya sampai kembali pada proses
pertama dan berulang.
Ketentuan
dari algoritma Round-Robin
- Jika kwanta habis dan proses belum selesai maka
proses Running itu menjadi Ready (Runnable) dan pemroses dialihkan ke
proses lain.
- Jika kwanta belum habis dan proses menunggu suatu
kejadian (misalnya menunggu selesainya suatu sistem operasi I/O), maka
proses Running itu menjadi Blocked dan pemroses dialihkan ke proses lain.
- Jika kwanta belum habis tapi proses telah selesai
maka proses Running itu diakhiri dan pemroses dialihkan ke proses lain.
Algoritma
penjadwalan itu dapat diimplementasikan sbb,
- Sistem mengelola senarai proses Ready (Runnable)
sesuai urutan kedatangan.
- Sistem mengambil proses yang beraa di ujung depan
antrian Ready menjadi Running.
- Bila kwanta belum habis dan proses selesai maka
sistem mengambil proses di ujung depan antrian proses ready.
- Jika kwanta habis dan proses belum selesai maka
tempatkan proses Running ke ekor antrian proses Ready dan sistem mengambil
proses di ujung depan antrian proses Ready.
Masalah
penjadwalan ini adalah dalam hal menentukan besar kwanta, yaitu:
- Kwanta terlalu besar menyebabkan waktu tanggap
besar dan turn arround time rendah.
- Kwanta terlalu kecil mengakibatkan peralihan
proses terlalu banyak sehingga menurunkan efisiensi pemroses.
Harus
ditetapkan besar kwanta waktu yang optimal berdasarkan kebutuhan sistem
terutama dari hasil percobaan atau data historis dari sistem. Besar kwanta
waktu beragam yang bergantung beban sistem.
Contoh :
Berikut adalah contoh kasus seperti pada FCFS namun diselesaikan dengan metode
Round-Robin dengan quantum = 1
Process
|
A
|
B
|
C
|
D
|
E
|
Mean
|
Finsih
Time
|
4
|
18
|
17
|
20
|
15
|
|
Arival
Time
|
0
|
2
|
4
|
6
|
8
|
|
TAT
|
4
|
16
|
13
|
14
|
7
|
10.80
|
Service
Time
|
3
|
6
|
4
|
5
|
2
|
|
NTAT
|
1.33
|
2.67
|
3.25
|
2.80
|
3.50
|
2.71
|
2. Shortest Remaining First (SRF)
Pada algoritma ini, proses dengan waktu pemrosesan
terendah yang akan dijalankan terlebih dahulu, walau pun proses tersebut baru
tiba di antrean proses. Selain itu, jika da proses yang sedang berjalan, dapat
di ambil alih oleh proses yang memiliki waktu pemrosesan lebih sedikit. Proses
ini merupakan Penjadwalan
berprioritas.dinamis.
Yaitu untuk timesharing melengkapi SJFPada SRF, proses dengan
sisa waktu jalan diestimasi terendah dijalankan,termasuk proses-proses yang
baru tiba.
Pada SJF, begitu proses dieksekusi, proses dijalankan sampai selesai. Pada SRF,
proses yang sedang berjalan (running) dapat diambil alih prosesbaru dengan sisa
waktu jalan yang diestimasi lebih rendah
Kelemahan:
SRT
mempunyai overhead yang lebih besar dibandingkan SJF. SRT memerlukan
penyimpanan waktu layanan yang telah dihabiskan proses dan kadang-kadang harus
menangani peralihan.
- Tibanya proses-proses kecil akan segera
dijalankan.
- Proses-proses lebih lama berarti dengan lama dan
variasi waktu tunggu lebih lama dibandingkan pada SJF.
Secara
teoritis SRT memberi waktu tunggu minimum tapi karena adanya overhead peralihan
maka pada situasi tertentu SJF bisa memberi kinerja yang lebih baik dibanding
SRT.
Tabel Contoh Shortest Job First
Contoh: Ada 4 buah proses yang datang berurutan yaitu P1 dengan arrival
time pada 0.0 ms dan burst time 7 ms, P2 dengan arrival time
pada 2.0 ms dan burst time 4 ms, P3 dengan arrival time pada 4.0
ms dan burst time 1 ms, P4 dengan arrival time pada 5.0 ms dan burst
time 4 ms. Hitunglah waiting time rata-rata dan turnaround time
dari keempat proses tersebut dengan mengunakan algoritma SJF. Average
waiting time rata-rata untuk ketiga proses tersebut adalah sebesar (0
+6+3+7)/4=4 ms.
3. Priority Schedulling (PS)
Priority Schedulling Adalah tiap proses
diberi prioritas dan proses yang berprioritas tertinggi mendapat jatah
waktu lebih dulu (running). Berasumsi bahwa masing-masing proses
memilikiprioritas tertentu, sehingga akan dilaksanakan berdasar prioritas yang
dimilikinya.Ilustrasi yang dapat memperjelas prioritas tersebut adalah dalam
komputer militer,dimana proses dari jendral berprioritas 100, proses dari
kolonel 90, mayorberprioritas 80, kapten berprioritas 70, letnan berprioritas
60 dan seterusnya. DalamUNIX perintah untuk mengubah prioritas menggunakan
perintah nice.Pemberian prioritas diberikan secara :
a. Statis
(static priorities)Berarti prioritas tidak berubah.
Keunggulan :
1. Mudah
diimplementasikan.
2. Mempunyai
overhead relatif kecil.
Kelemahan :
1. Tidak
tanggap terhadap perubahan lingkungan yang mungkin menghendaki penyesuaian
prioritas.
b.
Dinamis (dynamic priorities)
Merupakan mekanisme untuk menanggapi perubahan lingkungan
sistemberoperasi. Prioritas awal yang diberikan ke proses mungkin hanya
berumurpendek setelah disesuaikan ke nilai yang lebih tepat sesuai lingkungan.
Kelemahan
:
Implementasi mekanisme prioritas dinamis lebih kompleks dan mempunyai overhead
lebih besar. Overhead in diimbangi dengan peningkatan daya tanggap
sistem.Kebijaksanaan yang diterapkan adalah jaminan proses-proses mendapat
layanan
adil dari pemroses dalam arti jumlah waktu pemroses yang
sama.Keunggulannya penjadwalan berpriorita adalah memenuhi kebijaksanaan yang ingin
mencapai maksimasi suatu kriteria diterapkan. Algoritma ini dapat dikombinasikan,
yaitu dengan mengelompokkan proses-proses menjadi kelas-kelas prioritas.
Penjadwalan berprioritas diterapkan antar kelas-kelas
proses itu.Algoritma penjadwal akan menjalankan : proses runnable untuk
prioritas 4 lebihdulu secara round robin, apabila kelas 4 semua sudah diproses,
selanjutnya akanmenjalankan proses runnable untuk prioritas 3 secara round
robin, apabila kelas3 semua sudah diproses (habis), selanjutnya akan
menjalankan proses runnableuntuk prioritas 2 secara round robin, dan
seterusnya,
Contoh penjadwalan berprioritas
Proses-proses
yang sangat banyak operasi masukan/ keluaran dan menghabiskan kebanyakan waktu
proses untuk menunggu selesainya operasi masukan/ keluaran. Proses demikian
disebut I/O bound process. Proses-proses ini dapat diberi prioritas sangat
tinggi sehingga begitu proses-proses memerlukan pemrosesan segera saja
diberikan dan proses akan segera memulai permintaan masukan/ keluaran
berikutnya sehingga menyebabkab proses Blocked menunggu selesainya operasi
masukan/ keluaran. Dengan demikian pemroses segera dialihkan, dapat
dipergunakan oleh proses-proses lain tanpa mengganggu proses I/O bound.
Proses-proses I/O bound berjalan paralel bersama proses-proses lain yang
benar-benar memerlukan pemroses.
Proses-proses
yang sangat banyak operasi masukan/ keluaran kalau harus menunggu lama untuk
memakai pemroses (karena diberi proiritas rendah) hanya akan membebani mamori
karena tidak selesai-selesai menunggu operasi masukan/ keluaran dan menunggu
jatah pemroses.
4. Guaranteed Schedulling (GS)
Penjadwalan ini memberikan janji
yang realistis (memberi daya pemroses yangsama) untuk membuat dan menyesuaikan
performance adalah jika ada N pemakai,sehingga setiap proses (pemakai) akan
mendapatkan 1/N dari daya pemroses CPU.Untuk mewujudkannya, sistem harus selalu
menyimpan informasi tentang jumlahwaktu CPU untuk semua proses sejak login dan
juga berapa lama pemakai sedanglogin. Kemudian jumlah waktu CPU, yaitu waktu
mulai login dibagi dengan n,sehingga lebih mudah menghitung rasio waktu CPU.
Karena jumlah waktupemrosestiap pemakai dapat diketahui, maka dapat dihitung
rasio antara waktu pemrosesyang sesungguhnya harus diperoleh, yaitu 1/N waktu
pemroses seluruhnya danwaktu pemroses yang telah diperuntukkan proses itu
Contoh GS :
