1. CSS 430: Operating Systems - Process Synchronization
Thread Synchronization in ThreadOS: Implementing SysLib methods join(), exit(), rawread(), rawwrite(), sync()
Joe McCarthy
CSS 430: Operating Systems - Process Synchronization

2. CSS 430: Operating Systems - Process Synchronization
Monitors
A high-level abstraction that provides a convenient and effective mechanism for process synchronization
Only one process may be active within the monitor at a time
CSS 430: Operating Systems - Process Synchronization

3. CSS 430: Operating Systems - Process Synchronization
Syntax of a Monitor
CSS 430: Operating Systems - Process Synchronization

4. Schematic view of a Monitor
CSS 430: Operating Systems - Process Synchronization

5. CSS 430: Operating Systems - Process Synchronization
Condition Variables
Condition x, y;
Operations on a condition variable:
x.wait () – a process that invokes the operation is suspended
x.signal () – resumes one of processes (if any) that invoked x.wait ()
CSS 430: Operating Systems - Process Synchronization

6. Monitor with Condition Variables
CSS 430: Operating Systems - Process Synchronization

7. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
Java provides synchronization at the language-level
Thread-safe
Every Java Object has an associated lock
This lock is acquired by invoking a synchronized method
This lock is released when exiting the synchronized method.
Threads wanting to acquire the object lock are placed in the entry set for the object lock
CSS 430: Operating Systems - Process Synchronization

8. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
When a thread invokes wait(): 1. It releases the object lock 2. Its state is set to Blocked 3. It is placed in the wait set for the object
When a thread invokes notify(): 1. A thread T from the wait set is selected 2. T is moved from the wait set to the entry set 3. The state of T is set to Runnable
CSS 430: Operating Systems - Process Synchronization

9. CSS 430: Operating Systems - Process Synchronization
CSS 430: Operating Systems - Process Synchronization

10. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
/usr/apps/CSS430/examples/os-book/ch6/java-synchronization/boundedbuffer
CSS 430: Operating Systems - Process Synchronization

11. CSS 430: Operating Systems - Process Synchronization
Java Synchronization
notify() may not notify the correct thread!
/usr/apps/CSS430/examples/os-book/ch6/java-synchronization/boundedbuffer
CSS 430: Operating Systems - Process Synchronization

12. CSS 430: Operating Systems - Process Synchronization
Test2e
class Test2e extends Thread {
public void run() {
String[] args1 = SysLib.stringToArgs( "TestThread2 a " );
String[] args2 = SysLib.stringToArgs( "TestThread2 b " );
String[] args3 = SysLib.stringToArgs( "TestThread2 c " );
String[] args4 = SysLib.stringToArgs( "TestThread2 d " );
String[] args5 = SysLib.stringToArgs( "TestThread2 e " );
SysLib.exec( args1 );
SysLib.exec( args2 );
SysLib.exec( args3 );
SysLib.exec( args4 );
SysLib.exec( args5 );
for (int i = 0; i < 5; i++ ) {
int tid = SysLib.join();
SysLib.cout( "Thread tid=" + tid + " done\n” );
SysLib.cout( "Test2e finished; total time = " + totalTime + "\n" );
SysLib.exit(); }
CSS 430: Operating Systems - Process Synchronization

13. CSS 430: Operating Systems - Process Synchronization
TestThread2
class TestThread2 extends Thread { …
public void run() {
long totalExecutionTime = 0;
long totalWaitTime = 0;
activationTime = new Date().getTime();
for ( int burst = cpuBurst; burst > 0; burst -= TIMEQUANTUM ) {
totalExecutionTime += TIMEQUANTUM;
SysLib.sleep( TIMEQUANTUM ); }
completionTime = new Date().getTime( );
long responseTime = activationTime - submissionTime;
totalWaitTime = completionTime - submissionTime - executionTime;
long turnaroundTime = completionTime - submissionTime;
SysLib.cout(
String.format(
"%05d: Thread[%s]: response: %5d; wait: %5d; execution: %5d; turnaround: %5d\n",
completionTime % , name,
responseTime, totalWaitTime, totalExecutionTime, turnaroundTime ) );
SysLib.exit();
CSS 430: Operating Systems - Process Synchronization

14. CSS 430: Operating Systems - Process Synchronization
Test2e output
d :ThreadOS0 joe$ java Boot
threadOS ver 1.0:
Type ? for help
threadOS: a new thread (thread=Thread[Thread-4,2,main] tid=0 pid=-1)
-->l Shell
l Shell
threadOS: a new thread (thread=Thread[Thread-6,2,main] tid=1 pid=0)
shell[1]% Test2e
Test2e
threadOS: a new thread (thread=Thread[Thread-9,2,main] tid=2 pid=1)
threadOS: a new thread (thread=Thread[Thread-11,2,main] tid=3 pid=2)
threadOS: a new thread (thread=Thread[Thread-13,2,main] tid=4 pid=2)
threadOS: a new thread (thread=Thread[Thread-15,2,main] tid=5 pid=2)
threadOS: a new thread (thread=Thread[Thread-17,2,main] tid=6 pid=2)
threadOS: a new thread (thread=Thread[Thread-19,2,main] tid=7 pid=2)
Thread[b]: response time = 3942 turnaround time = 4944 execution time = 1002
Thread tid=4 done
Thread[e]: response time = 6944 turnaround time = 7445 execution time = 501
Thread tid=7 done
Thread[a]: response time = 2941 turnaround time = 7948 execution time = 5007
Thread tid=3 done
Thread[c]: response time = 4945 turnaround time = 7951 execution time = 3006
Thread tid=5 done
Thread[d]: response time = 5944 turnaround time = execution time = 6009
Thread tid=6 done
Test2e finished
shell[2]% exit
exit
-->q b e d a c
CSS 430: Operating Systems - Process Synchronization

15. SysLib.join(), Kernel.WAIT
public class SysLib { …
public static int join( ) {
return Kernel.interrupt( Kernel.INTERRUPT_SOFTWARE,
Kernel.WAIT, 0, null ); }
public class Kernel {
public static int interrupt( int irq, int cmd, int param, Object args ) {
// Looks like myTcb is not used anywhere; newTcb declared & used below
// TCB myTcb;
switch( irq ) {
case INTERRUPT_SOFTWARE: // System calls
switch( cmd ) {
case WAIT:
// get the current thread id
// let the current thread sleep in waitQueue under the
// condition = this thread id
// System.out.print( " * " );
return OK; // return a child thread id who woke me up
CSS 430: Operating Systems - Process Synchronization

16. enqueueAndSleep(), dequeueAndWakeup()
CSS 430: Operating Systems - Process Synchronization

17. SysLib.exit(), Kernel.EXIT
public class SysLib { …
public static int exit( ) {
return Kernel.interrupt( Kernel.INTERRUPT_SOFTWARE,
Kernel.EXIT, 0, null ); }
public class Kernel {
public static int interrupt( int irq, int cmd, int param, Object args ) {
// Looks like myTcb is not used anywhere; newTcb declared & used below
// TCB myTcb;
switch( irq ) {
case INTERRUPT_SOFTWARE: // System calls
switch( cmd ) {
case EXIT:
// get the current thread's parent id
// search waitQueue for and wakes up the thread under the
// condition = the current thread's parent id
// tell the Scheduler to delete the current thread
// (since it is exiting)
return OK;
CSS 430: Operating Systems - Process Synchronization

18. SysLib.rawread(), Kernel.RAWREAD
public class SysLib { …
public static int rawread( int blkNumber, byte[] b ) {
return Kernel.interrupt( Kernel.INTERRUPT_SOFTWARE,
Kernel.RAWREAD, blkNumber, b ); }
public class Kernel {
public static int interrupt( int irq, int cmd, int param, Object args ) {
// Looks like myTcb is not used anywhere; newTcb declared & used below
// TCB myTcb;
switch( irq ) {
case INTERRUPT_SOFTWARE: // System calls
switch( cmd ) {
case RAWREAD: // read a block of data from disk
while ( disk.read( param, ( byte[] )args ) == false )
ioQueue.enqueueAndSleep( COND_DISK_REQ );
while ( disk.testAndResetReady( ) == false )
ioQueue.enqueueAndSleep( COND_DISK_FIN );
return OK;
CSS 430: Operating Systems - Process Synchronization

19. Disk.read(), Disk.testAndResetReady()
public class Disk { …
public synchronized boolean read( int blockId, byte buffer[] ) {
if ( blockId < 0 || blockId > diskSize ) {
SysLib.cerr( "threadOS: invalid blockId for read\n" );
return false; }
if ( command == IDLE && readyBuffer == false ) {
this.buffer = buffer;
targetBlockId = blockId;
command = READ;
notify( );
return true;
} else
public synchronized boolean testAndResetReady( ) {
if ( command == IDLE && readyBuffer == true ) {
readyBuffer = false;
CSS 430: Operating Systems - Process Synchronization

20. Disk.waitCommand(), Disk.finishCommand()
public class Disk { …
private synchronized void waitCommand( ) {
while ( command == IDLE ) {
try {
wait( );
} catch ( InterruptedException e ) {
SysLib.cerr( e.toString( ) + "\n" ); }
readyBuffer = false;
private synchronized void finishCommand( ) {
command = IDLE;
readyBuffer = true;
SysLib.disk( ); // a disk interrupt
CSS 430: Operating Systems - Process Synchronization

21. CSS 430: Operating Systems - Process Synchronization
Disk.run()
public class Disk { …
public void run ( ) {
while ( true ) {
waitCommand( );
seek( );
switch( command ) {
case READ:
System.arraycopy( data, targetBlockId * blockSize,
buffer, 0, blockSize );
break;
case WRITE:
case SYNC: }
finishCommand( );
CSS 430: Operating Systems - Process Synchronization

22. Kernel.INTERRUPT_DISK
public class SysLib { …
public static int rawread( int blkNumber, byte[] b ) {
return Kernel.interrupt( Kernel.INTERRUPT_SOFTWARE,
Kernel.RAWREAD, blkNumber, b ); }
public class Kernel {
public static int interrupt( int irq, int cmd, int param, Object args ) {
// Looks like myTcb is not used anywhere; newTcb declared & used below
// TCB myTcb;
switch( irq ) {
case INTERRUPT_DISK: // Disk interrupts
// wake up the thread waiting for a service completion first
ioQueue.dequeueAndWakeup( COND_DISK_FIN );
// wake up a thread waiting for a request acceptance
ioQueue.dequeueAndWakeup( COND_DISK_REQ );
return OK;
CSS 430: Operating Systems - Process Synchronization