SINKRONISASI

PROSES-PROSES

Dipresentasikan Oleh Kelompok IV

1. DANANG NURDIANSYAH (10/309040/PPA/03399)

2. MURYANTO (10/309060/PPA/03410)
3. KANDI HARIANTO (10/309044/PPA/03401)
4. I MADE PARTHA WIGUNA (10/309392/PPA/03421)
 LATAR BELAKANG
• Adanya Proses-proses konkuren
( concurrent process )
– Proses yang bersifat independen/
independence process
– Proses yang bersifat kooperatif / cooperating
process
• Proses konkuren yang kooperatif saling
berkomunikasi 1 dengan yang lain
– Memungkinkan sharing data
 Race Condition
• Adanya akses data secara bersama, oleh
bebera proses, memungkinkan data tidak
konsisten / data inconsistence
• Perlunya mekanisme untuk menjamin
eksekusi yang berurutan pada proses-
proses yang bekerjasama
 Pemakaian Bounded Buffer
• Producer akan menambah/memberi data
• Consumer akan menerima/menggunakan
data
• Buffer, sebagai penampungan data
 Shared data
#define BUFFER_SIZE 10
Typedef struct {
…
} item;
Item buffer {BUFFER_SIZE};
Int in=0;
Int out=0;
Int counter=0;
 Producer
Producer:
while (true) {
/* produce an item and put in nextProduced*/
while (counter == BUFFER_SIZE); // do nothing
buffer [in] = nextProduced;
in = (in + 1) % BUFFER_SIZE;
counter++;
}
 Consumer
Consumer:
while (1) {
while (counter == 0); // do nothing
nextConsumed = buffer[out];
out = (out + 1) % BUFFER_SIZE;
counter--;
/* consume the item in nextConsumed */
}
Peryataan counter++ dan counter-- , harus
dilakukan secara atomik ( seluruh peryataan
sampai selesai tanpa interupsi)
• Pernyataan counter++ dapat diimplementasikan
dalam bahasa mesin sebagai berikut
– register1 = counter
– register1 = register1 + 1
– counter = register1
• Pernyataan counter-- dapat diimplementasikan
dalam bahasa mesin sebagai berikut
– register2 = counter
– register2 = register2 -1
– counter = register2
 Misal counter=5
• producer :register1 = counter {register1 = 5}
• producer :register1 = register1 + 1 {register1 = 6}
• consumer :register2 = counter {register2 = 5}
• consumer : register2 = register2 -1 {register2 = 4}
• producer :counter = register1 {counter = 6 }
• consumer :counter = register2 {counter = 4}

Nilai counter menjadi tidak konsisten !!!

“ Untuk mencegah race condition, maka proses yang

konkuren harus di sinkronisasi ”
 Masalah Critical Section
• Banyak proses kemungkinan akses data
yang sama
• Proses kemungkinan memiliki kode
segmen, dimana jika kode segmen
tersebut dieksekusi, maka proses-proses
tersebut dapat saling mengubah variabel,
mengupdate tabel, menulis ke dalam file
dll
 Solusi Critical Section
– Setiap proses harus meminta ijin jika akan mengakses critical
section-nya
– Akhir dari critical section diikuti oleh exit section
– Kode pengingat terletak pada remainder section
– Skema struktur proses :

do{
entry section
critical section
exit section
remainder section

} while(1);
 Syarat Solusi Critical Section
• Mutual Exclusion
– Jika sebuah proses sedang berada di critical section, tidak boleh
ada proses lain yang berada di critical section nya
• Progress
– Jika tidak ada proses di critical section, dan ada beberapa
proses yang ingin masuk ke critical section, maka hanya proses
yang berada di entry critical section yang boleh berpartisipasi
untuk memasuki critical section
• Bounded Waiting
– batasan waktu tunggu sebuah proses untuk masuk ke critical
section, setelah mereka meminta ijin untuk masuk dan sebelum
permintaan tersebut terpenuhi

Asumsi ; setiap proses dieksekusi dengan kecepatan bukan nol

 Gambaran Proses
Pada Kernel Mode
Kernel code memanggil fungsi penjadwalan
sendiri. setiap waktu banyak proses yang berjalan
dalam kernel mode,akibatnya sangat mungkin
untuk terjadi race condition,contoh, dalam kernel
mode terdapat struktur data yang menyimpan list
file yang terbuka, list tersebut termodofikasi bila
ada data file yang baru dibuka atau ditutup,dengan
menambah atau menghapus dari list, race
condition timbul ketika ada dua file yang dibuka
dan ditutup bersamaan, untuk mengatasi hal
tersebut kernel mempunyai metode
 Pendekatan Umum Menyikapi
Critical Section Sistem Operasi
a. Preemptive kernel. pada mode ini proses yang sedang dieksekusi
dalam kernel diizinkan untuk diinterupsi oleh proses lain yang
memenuhi syarat, akibatnya mode ini juga rentan terkena race
condition. Keuntungannya adalah mode ini amat efektif untuk
digunakan dalam real time programming, namun mode ini lebih sulit
diimplementasikan dari pada mode non preemptive kernel. Mode ini
diimplementasikan oleh Linux versi 2.6 dan versi komersial linux
lainnya
b. non preemptive kernel. mode yang tidak memperbolehkan suatu
proses yang berjalan dalam kernel mode diinterupsi oleh proses
lain, proses lain hanya bisa dijalankan setelah proses yang ada
dalam kernel selesai dieksekusi, implementasinya memang lebih
mudah dibandingkan dengan preemptive kernel, mode ini
diimplementasikan lewat Windows XP dan Windows 2000
NEXT ........
 Solusi Critical Section
Ada dua jenis solusi masalah critical section, yaitu:

1.Solusi perangkat lunak.

Dengan menggunakan algoritma-alogoritma yang nilai
kebenarannya tidak tergantung pada asumsi-asumsi lain,
selain bahwa setiap proses berjalan pada kecepatan yang
bukan nol.

2.Solusi perangkat keras.

Tergantung pada beberapa instruksi mesin tertentu,
misalnya dengan me-non-aktifkan interupsi atau dengan
mengunci suatu variabel tertentu
 Cara Pemecahan Masalah
• Hanya dua proses , P0 and P1
• Struktur umum dari proses adalah Pi (proses lain Pj)
do {
entry section
critical section
exit section
reminder section
} while (1);

• Proses-proses dapat share variabel untuk

sinkronisasi
 Algoritma 1
• Shared variabel :
– int turn;
initially turn = 0
– turn = i  Pi dapat masuk ke dalam critical section
• Process Pi
do {
while (turn != i) ;
critical section
turn = j;
reminder section
} while (1);
• Memenuhi mutual exclusion, tapi tidak menuhi
progres
 Algoritma 2 (1)
• Menggunakan flag untuk setiap proses dan
memeriksa flag proses yang lain dan tidak
akan masuk critical section bila ada proses
lain yang sedang masuk.
 Algoritma 2 (2)
• Shared variabel :
– boolean flag[2];
initially flag [0] = flag [1] = false.
– flag [i] = true  Pi siap untuk masuk ke dalam critical
section
• Process Pi
do {
flag[i] := true;
while (flag[j]) ; critical section
flag [i] = false;
remainder section
} while (1);

• Memenuhi mutual exclusion, tapi tidak menuhi progres

 Algoritma 3 (1)
• Flag untuk meminta ijin masuk
– Setiap proses menge-set sebuah flag untuk
meminta ijin masuk. Lalu setiap proses men-
toggle bit untuk mengijinkan proses yang lain
untuk yang pertama
• Kombinasi shared variabel algoritma 1 & 2
 Algoritma 3 (2)
• Process Pi
do {
flag [i]:= true;
turn = j;
while (flag [j] and turn = j) ;
critical section
flag [i] = false;
remainder section
} while (1);

• Memenuhi ketiga persyaratan, memecahkan

masalah critical-section untuk kedua proses.
 Algoritma Bakery (1)
Critical section untuk n proses :
• Sebelum masuk ke dalam critical section, proses
menerima sebuah nomor. Pemegang nomor yang
terkecil masuk ke critical section.
• Jika ada dua proses atau lebih (Pi and Pj)
menerima nomor sama, maka proses dengan
indeks terkecil (i < j) yang dilayani lebih dulu untuk
masuk ke critical section. Misal Pi dilayani lebih
dulu, baru kemudian Pj.
• Skema penomoran selalu naik secara berurut,
contoh : 1,2,3,3,3,3,4,5...
 Algoritma Bakery (2)

• Shared data
boolean choosing[n];
int number[n];
Struktur data masing-masing diinisialisai false
dan 0.
 Algoritma Bakery (3)
• Algoritma
do {
choosing[i] = true;
number[i] = max(number[0], number[1], …, number [n – 1])
+1;
choosing[i] = false;
for (j = 0; j < n; j++) {
while (choosing[j]) ;
while ((number[j] != 0) && (number[j,j] < number[i,i])) ;
}
critical section
number[i] = 0;
remainder section
} while (1);
 Synchronization Hardware /
Perangkat Keras Sinkronisasi
Pada sistem multiprosessor, proses-pmroses bertindak independen.
Interupsi di satu pemroses tidak mempengaruhi pemroses-pemroses
yang lain. Pemroses-pemroses yang memakai memori bersama maka
pengaksesan terhadap suatu memori dijaga pada tingkat perangkat
keras agar tidak boleh pemroses lain tidak dapat mengakses suatu
lokasi yang sama di saat yang sama.

Perancang perangkat keras menyediakan instruksi-instruksi atomik

yang tak dapat diinterupsi. Instruksi dilaksanakan sampai selesai.
Instruksi ini biasanya dilaksanakan dengan cara mengunci bus
sehingga pemroses-pemroses lain tak dapat menggunakan bus.
Pemroses yang mengunci bus dengan leluasa membaca dan/atau
memodifikasi suatu lokasi memori.
Metode Processor Synchronous

Central Processing Unit (CPU) mempunyai

suatu mekanisme yang dinamakan
interrupt. Di dalam sistem operasi,
mekanisme ini digunakan secara intensif,
atau dengan kata lain, banyak Konsep
sistem operasi yang menggunakan
mekanisme ini. Sebagai contoh: system
call, process scheduling, dsb.
 Main Modul :
Prosesor Atmel ARM tm

00 CLI ' masuk ke Critical Section dengan ‘

cara men-disable interrupt
01 ADD r1,r2 ' Critical Section
02 .... ‘ Critical Section
03 SBI ' pergi dari Critical Section dengan
‘ cara men-enable interrupt
04 .. ' Remainder Section
 Metode Memory
Synchronous
• Hal tersebut benar adanya, mekanisme
memory synchronous memakai suatu nilai
yang disimpan di dalam memori, dan jika
suatu proses berhasil mengubah nilai ini,
maka proses tersebut akan meneruskan
ke instruksi selanjutnya. Tetapi jika tidak,
maka proses ini akan berusaha terus
untuk mengubah nilai tersebut.
 Metode Test and Set
Metode ini melakukan testing dan memodifikasi isi memori secara atomik
menggunakan fungsi Test and Set sebagai berikut :
boolean TestAndSet (boolean &target)
{
boolean rv = target;
tqrget = true;
return rv;
}
variable umum yang digunakan pada metode ini adalah boolean
Contonya
lock = false;
Sedangkan Process Pi mempunyai struktur sebagai berikut :
do {
while (TestAndSet(lock)) ;
critical section
lock = false;
remainder section
}
 Metode Swap

Prosedur swap adalah sebagai berikut :

void Swap(boolean &a, boolean &b) {
boolean temp = a;
a = b;
b = temp;
}
 Metode Swap
Untuk menyelesaikan permasalahan mutual exclusion
menggunakan prosedur swap, variabel umum yang digunakan
adalah boolean lock; boolean waiting[n];
Kedua variable diatas diinisialisasi false. Sedangkan struktur
process Pi adalah sebagai berikut :
do {
key = true;
while (key == true)
Swap(lock,key);
critical section
lock = false;
remainder section
}
 Instruksi Atomik
adalah satu atau sekelompok instruksi yang tidak dapat
diberhentikan sampai instruksi tersebut selesai. Kita telah
memakai instruksi ini pada method testAndSet.
Instruksi yang dimaksud di sini adalah instruksi-instruksi
pada high-level programming, bukanlah pada tingkat
instruksi mesin yang memang sudah bersifat atomic.
Sebagai contoh : i++ pada suatu bahasa pemrograman
akan diinterpertasikan beberapa instruksi mesin yang
bersifat atomic sbb :
00 Load R1,i ' load nilai i ke register 1
01 Inc R1 ' tambahkan nilai register 1 dengan angka 1
02 Store i,R1 ' simpan nilai register 1 ke i
 Instruksi Atomik
Designer processor dapat mengimplementasi konsep ini
dengan dua cara yaitu :
1. mengimplementasi instruksi yg build-in
2. mengimplementasi processor mampu
membuat suatu instruksi menjadi atomic
Intel Pentium memakai cara yang kedua, yaitu dengan
adanya suatu perintah LOCK-Assert. Dengan perintah ini
maka semua instruksi dapat dijadikan atomic. Sedangkan
SPARC dan IBM mengimplementasikan suatu rutin yang
bersifat atomic seperti swap dan compareAndSwap.
NEXT .....................
 Semaphore
• Perangkat sinkronisasi yang
membutuhkan busy waiting
• Semaphore S – integer variable
– Dapat dijamin akses ke var. S oleh dua
operasi atomik:
• wait (S): while S ≤0 do no-op;
S := S –1;
• signal (S): S := S + 1;
 Contoh: n proses
• Shared variables
– Var mutex: semaphore
– initially mutex= 1
• Process Pi
do {
wait(mutex);
critical section
signal(mutex);
remainder section
} while (1);
 Implementasi Semaphore
• Didefinisikan sebuah Semaphore dengan
sebuah record
Typedef struct {
Int value;
Struct process *L;
} semaphore;
• Diasumsikan terdapat 2 operasi sederhana
– Block menhambat proses yang akan masuk
– wakeup(P) memulai eksekusi pada proses P yang
diblock
 Implementasi Semaphore (2)
• Operasi Semaphore-nya menjadi:
wait(S):
S.value--;
If (S.value < 0) {
add this process to S.L;
block;
}
signal(S):
S.value++;
if (S.value <= 0) {
remove a process P from S.L;
wakeup(P);
}
 Masalah Klasik Sinkronisasi
• Bounded-Buffer Problem

• Readers and Writers Problem

• Dining-Philosophers Problem
 Bounded-Buffer Problem
• Shared data
semaphore full, empty, mutex;
Initially:
full = 0, empty = n, mutex= 1
Bounded-Buffer Problem :
Producer-Consumer
 Readers-Writers Problem
• Shared data

semaphore mutex, wrt;

Initially

mutex= 1, wrt= 1, readcount= 0

 Readers-Writers Problem (2)
• WrittersProcess • Readers Process
wait(mutex);
readcount++;
if (readcount== 1)
wait(wrt);
wait(rt);
… signal(mutex);
…
writing is performed
reading is performed
… …
wait(mutex);
signal(wrt);
readcount--;
if (readcount== 0)
signal(wrt);
signal(mutex):
NEXT .....................
Dining-Philosophers Problem

• Shared data
semaphore chopstick[5];
Semua inisialisasi bernilai 1
Dining-Philosophers Problem
• Philosopher i:
do {
wait(chopstick[i])
wait(chopstick[(i+1) % 5])
…
eat
…
signal(chopstick[i]);
signal(chopstick[(i+1) % 5]);
…
think
…
} while (1);
 Solusi Tingkat Tinggi

• Motif:
– Operasi wait(S) dansignal(S) tersebar pada code program
=> manipulasi langsung struktur data semaphore
– Bagaimana jika terdapat bantuan dari lingkungan HLL (programming) untuk
sinkronisasi ?
– Pemrograman tingkat tinggi disediakan sintaks-sintaks khusus untuk menjamin
sinkronisasi antar proses, thread
• 􀁺Misalnya:
• 􀁺Monitor & Condition
• 􀁺Conditional Critical Region
 Monitor
• Monitor mensinkronisasi sejumlah proses:
– Suatu saat hanya satu yang aktif dalam monitor dan yang lain
menunggu
• Bagian dari bahasa program (mis. Java).
– Tugas compiler menjamin hal tersebut terjadi dengan
menerjemahkan ke “low level synchronization” (semphore,
instruction set dll)
• Cukup dengan statement (deklarasi) suatu section/fungsi
adalah monitor => mengharuskan hanya ada satu
proses yang berada dalam monitor (section) tsb
Monitor (2)
 Monitor (3)
• Proses-proses harus disinkronisasikan di dalam monitor:
– Memenuhi solusi critical section.
– Proses dapat menunggu di dalam monitor.
– Mekanisme: terdapat variabel (condition) dimana proses dapat
menguji/menunggu sebelum mengakses “critical section”
varx, y: condition
 Monitor (4)
• Condition: memudahkan programmer untuk menulis
code pada monitor.
• Misalkan: varx: condition ;
• Variabel condition hanya dapat dimanipulasi dengan
operasi: wait() dan signal()
– x.wait() jika dipanggil oleh suatu proses maka proses tsb. Akan
suspend – sampai ada proses lain yang memanggil: x. signal()
– x.signal() hanya akan menjalankan (resume) 1 proses saja yang
sedang menunggu (suspend) (tidak ada proses lain yang wait
maka tidak berdampak apapun)
Skema Monitor
Gambaran Implementasi Sinkronisasi
Pada Beberapa Sistem Operasi

Solaris II dan
Windows 2000
 Atomic transaction

•Koleksi dari instruksi-instruksi( operasi )

pada sebuah fungsi logika tunggal sering
disebut sebagai transaski.
•Transaksi sebagai sebuah program yang
mengakse dan mungkin juga melakukan
perubahan item data dari beberapa file
yang ada di disk.
•Transaksi merupakn urutan dari operasi
read dan write yang akan berhenti ketika
abort maupun commit.
 Memory transaction
• Sebuah memory transaction ( transaski
memori ) adalah urutan operasi read-write
pada memory secara atomik. Jika operasi
sampai selesai atau komplet maka sebuah
transaski dinyatakan commit, kalau
sebaliknya maka harus di abort/ digagalkan
dan dibatalkan(rollback)
• Pada transaski aatomik harus bias menjamin
bahwa abort terhadap sebuah transaksi tidak
boleh menimbulkan efek perubahan status
data yang diupdate
 Untuk menjamin bahwa system atomic
maka pertama kali perlu
mengidentifikisasi media pemyimpan yang
dipergunakan untk menyimpan data yang
dilibatkan dalam transaksi
 Beberapa tipe media penyimpan yang dibedakan bedsar kecepatan,
kapasistas dan ketahannnya terhadap kerusakan :

• Volatile storage
– tidak bertahan saat sistem crash
contoh: memori utama, cache memori
– akses sangat cepat karena menggunakan metode akses
langsung
• Non volatile storage
– bertahan saat sistem crash , namun tetap berpeluang akan
terjadinya kerusakan yang memungkinkan data dan infromasi
yang disimpan akan hilang
– contoh : disk magnetik dan tape magnetic
– kecepatan akses lebih lambat dari volatile storage
• Stabel storage
– Data dan informasi yang telah tersimpan tidak hilang ,
pendekatanya dengan membuat beberapa salinan pada media
nonvolatile
 Log Based Recovery

• log menjadi sarana perekaman perubahan

yang terjadi pada data
• setiap record log medeskripsikan sebuah
operasi tunggal dari operasi write
 Log Based Recovery fields

• Nama Transaksi / transaction indentifier,

memiliki nilai unik yang menunjukan
identifikasi transaksi operasi write
• Pengidentifikasi data/ data-item identifier,
nama unik yang menunjukkan item data yang
ditulis
• Nilai lama / Old value, menunjukan nilai item
data sebelum operasi write dijalankan
• Nilai baru/ New value, menunjukkan item
data setelah operasi write dijalankan
 operasi-operasi selama
pemrosesan transaksi pada log
• < Ti start > ditulis di log, sebelum transaksi
Ti dieksekusi
• < Ti commit > ditulis di log, ketika Ti
commit
 Prosedur yang dipakai untuk
recovery :
• Undo ( Ti ), yang merekam kembali
( restore ) nilai semua item data yang
diupdate oleh transaksi Ti ke nilai
awal/sebelumnya
• Redo( Ti ), yang membuat semua nilai item
data yang diupdate oleh transaksi Ti ke
nilai berikutnya
 Ketika terjadi kegagalan
• Transaksi Ti perlu di di undone jika log
terdapat < Ti start > namun tidak punya
< Ti commit >
• Transaki Ti perlu di redo jika log terdapat
< Ti start >dan juga punya < Ti commit >
 Checkpoint

• Ketika kegagalan terjadi seluruh isi log harus

diperiksa untuk menentukan transaksi mana
yang harus diulang dan mana yang
dikembalikan ke keadaan semula ( redo atau
undo )
• 2 pendekatan utama, yang perlu
dipertimbangkan :
– Proses pencarian memakan waktu
– Sebagian besar transaksi yang perlu diulangi,
sudah menuliskan perubahannya , sehingga tidak
perlu diulangi
 Checkpoint

• Untuk mengurangi beban kerja dan waktu

tambahan ini maka perlu dilakukan
checkpoint. Selama eksekusi disamping
perekaman ke file log
– Menuliskan semua record log yang ada di
volatile storage( biasanya mai memory ) ke
media penyimpan stabil
– Menuliskan semua data yang telah
dimodifikasi/ dirubah dari volatile stirage ke
stable storage/ media penyimpan stabil
 Operasi recovery membutuhkan
hal-hal berukut ini :
• Untuk seluruh transaksi Tk pada T, untuk
yang memiliki record < Tk commit >,
jalankan operasi redo(Tk )
• Untuk seluruh transaksi Tk pada T, yang
tidak memiliki record < Tk commit >,
jalankan operasi undo(Tk )
 Seriabilitas dalam transaski
• Sebuah schedule yang dimana setiap transaksi deksekusi
secara atomisasi disebut sebagai serial schedule.

• a serial schedule in which T0 is followed by T1

T0 T1
Read(A)
Write(A)
Read(B)
Write(B)
Read(A)
Write(A)
Read(B)
Write(B)
 a concurrent serializable
schedule
T0 T1
Read(A)
Write(A) Read(A)
Write(A)
Read(B)
Write(B) Read(B)
Write(B)

• Missal sebuah schedule S dimana memiliki 2 buah operasi Oi

dan Oj dari transaksi Ti dan Tj . Oi dan Oj akan terjadi konflik
jika mereka mengakses item data yang sama dan paling
sedikit 1 dari mereka melakukan operasi write
• write (A) dari T0 konflik dengan Read(A) T1. Akan tetapi
Write(A) pada T1 tidak mengalami konflik dengan Read(B) dari
T0 karena 2 operasi tersebut mengakses item data yang
berbeda.
• Jika Oi dan Oj adalah operasi-operasi
berbeda transaksi dan keduanya tidak
konfilk maka kita dapat melakukan
pertukaran( swap ) urutan dari Oi dan Oj
– Swap Read(B) dari T0 dengan Read(A) dari T1
– Swap Write(B) dari T0 dengan Write(A) dari T1
– Swap Write(B) dari T0 dengan Read(A) dari T1
• Hasil akhir dari swap-swap tersebut sama
dengan schedule serial sebelumnya. Jadi
schedule 2 adalah equivalent dengan
dengan serial schedule ( schedule 1 )
 Locking Protocol

• Salah satu cara untuk menjamin serializability

• Beberapa model cara item data dapat di lock :
– Shared , jika sebuah transaksi Ti menggunakan
mode ini ( dilambangkan dengan S ) pada item data
Q, maka Ti akan dapat membaca item data tersebut
namun tidak dapat mengubahnya
– Exclusive, jika sebuah transaksi Ti menggunakn
mode ini ( dilambangkan dengan X ) pada item data
Q, maka Ti akan dapat membaca item data tersebut
dan dapat mengubahnya
• Missal untuk mengakse data Q, sebuah
transaski Ti pertama kali harus menntukan
mode lock yang paling tepat. Jika Q tidak
sedang di lock maka Ti dapat mengkasesnya,
namun jika Q sedang di lock oleh transaksi
yang lain maka Ti harus menunggunya
khusunya jika Q sedang dilock dengan mode
eksklusiv, maka dia akan terus menunggu
sampai Q dibebaskan , selain itu dia dapat
ijin lock dan mengakses Q
 Dua (2) fase locking protocol :

• Fase pertumbuhan/ Growing Phase,

sebuah transaksi dapat melakukan
penguncian-penguncian , namun belum
melepaskan penguncian/locking walupun 1
buah
• Fase pelepasan/Shrinking Phase, sebuah
transaksi dapat melepaskan sejumlah
penguncian, tetapi belum melakukan
penguncian yang baru
 Timestamp Based Protocold

• digunakan untk menentukan urutan seriability

dengan memilih urutan transaksi sebbelumnya.
• Untuk setiap transaski Ti dalam sistem, maka
ditetapkan nilai berdasar waktu yang tetap dan unik
dengan notasi TS(Ti). Timestamp ditentukan sistem
seblum transaksi Ti mulai dikerjakan. Jika sebuah
transaksi TI telah diberi timesramp TS(Ti), dan
kemudian datang transaksi baru Tj , maka nilai
TS(Ti) < TS(Tj)
 Ada 2 metode sederhana
• Menggunkan jan komputer (system clock)
sebagai timestamp, sehingga timestamp
dari suatu transaksi akan sama dengan jam
komputer saat transaksi masuk sistem
• Menggunakan pencacah lojik ( logical
counter ), dimana timestamp sebuah
transaksi akan sama dengan nilai dari
counter ketika sebuah transaksi masuk ke
dalam sistem.
 2 nilai timestamp pada setiap item
data Q :
• W- timestamp(Q), menunjukkan nilai
terbesar dari setiap transaski yang
berhasil menjalankan operasi write(Q)
• R- timestamp(Q), menunjukkan nilai
timestamp terbesar dari setiap transaksi
yang berhasil menjalankan operasi
Read(Q)
 Protokol tersebut berjalan dengan
aturan sebagai berikut :
• Untuk transaksi Ti yang menjalankan operasi Read(Q)
– Jika TS(Ti) < W- timestamp(Q) , maka Ti perlu membaca kembali nilai
Q yang telah ditulis. Karenanya operasi read ini akan ditolak dan Ti
akan dibatalkan( rollback)
– Jika TS(Ti) >= W- timestamp(Q) , maka operasi read akan dieksekusi,
dan R-timestamp akan diisi dengan nilai maksimum dari R-
timestamp(Q) dan TS(Ti)
• Untuk transaksi Ti yang menjalankan operasi Write(Q)
– Jika TS(Ti) < R- timestamp(Q), maka nilai dari Q yang dihasilkan Ti
adalah nilai yang diinginkan sebelumnya( nilai tidak akan
dimanfaatkan ) dan Ti berasumsi bahwa nilai tersebut tidak pernah
dihasilkan, sehingga operasi ditolak dan Ti dibatalkan( rollback)
– Jika TS(Ti) < W- timestamp(Q), maka Ti sedang berusaha menulis nilai
Q yang kedaluwarsa, sehingga operasi write ditolak dan Ti
dibatalkan(Rollback)
– Selain 2 jenis hal di atas maka operari write akan dieksekusi
• Contoh ilustrasi: schedule possible under the timestamp protocol
• Diasumsikan bahwa sebuah transaksi diberi nilai timestamp segera
sebelum instruksi pertama. Pada gambaran ini TS(T2) < TS(T3), dan
schedule dimungkinkan dieksekusi dengan menggunakan protokol
timestamp ordering.

T2 T3
Read(B)
Read(B)
Write(B)
Read(A)
Read(A)
Write(A)