package examples.pilib
/**
* From Pi to Scala: Semaphores, monitors, read/write locks.
* Readers/writers locks.
*/
object rwlock {
import scala.concurrent.pilib._
class Signal extends Chan[unit] {
def send = write(())
def receive = read
}
class CountLock {
private val busy = new Signal
def get = busy.send
def release = busy.receive
spawn < release >
}
/** A binary semaphore
*/
class Lock {
private val busy = new Signal;
private val free = new Signal;
def get = busy.send;
def release = free.send;
spawn < (while (true) {
choice (
busy * (x => free.receive),
free * (x => ())
)
}) >
}
/** A monitor a la Java
*/
class JavaMonitor {
private val lock = new Lock
private var waiting: List[Signal] = Nil
def Wait = {
val s = new Signal
waiting = s :: waiting
lock.release
s.receive
lock.get
}
def Notify =
if (!waiting.isEmpty) {
waiting.head.send
waiting = waiting.tail
}
def NotifyAll =
while (!waiting.isEmpty) {
waiting.head.send
waiting = waiting.tail
}
def await(cond: => boolean): unit =
while (false == cond) (Wait)
}
/*
class Buffer[a](size: Int) extends JavaMonitor with {
var in = 0, out = 0, n = 0;
val elems = new Array[a](size);
def put(x: a) = synchronized {
await(n < size);
elems(out) = x;
out = (out + 1) % size;
}
def get: a = synchronized {
await(n > 0);
val x = elems(in);
in = (in + 1) % size;
x
}
}
*/
/** A readers/writers lock. */
trait ReadWriteLock {
def startRead: unit
def startWrite: unit
def endRead: unit
def endWrite: unit
}
/**
* A readers/writers lock, using monitor abstractions.
*/
class ReadWriteLock1 extends JavaMonitor with ReadWriteLock {
private var nactive: int = 0
private var nwriters: int = 0
def status =
System.out.println(nactive + " active, " + nwriters + " writers");
def startRead = synchronized {
await(nwriters == 0)
nactive = nactive + 1
status
}
def startWrite = synchronized {
nwriters = nwriters + 1
await(nactive == 0)
nactive = 1
status
}
def endRead = synchronized {
nactive = nactive - 1
if (nactive == 0) NotifyAll
status
}
def endWrite = synchronized {
nwriters = nwriters - 1
nactive = 0
NotifyAll
status
}
}
/** A readers/writers lock, using semaphores
*/
class ReadWriteLock2 extends ReadWriteLock {
private var rc: int = 0 // reading readers
private var wc: int = 0 // writing writers
private var rwc: int = 0 // waiting readers
private var wwc: int = 0 // waiting writers
private val mutex = new Lock
private val rsem = new Lock
private val wsem = new Lock
def startRead = {
mutex.get;
if (wwc > 0 || wc > 0) {
rwc = rwc + 1;
mutex.release;
rsem.get;
rwc = rwc - 1
}
rc = rc + 1;
if (rwc > 0) rsem.release;
mutex.release
}
def startWrite = {
mutex.get;
if (rc > 0 || wc > 0) {
wwc = wwc + 1;
mutex.release;
wsem.get;
wwc = wwc - 1
}
wc = wc + 1;
mutex.release
}
def endRead = {
mutex.get;
rc = rc - 1;
if (rc == 0 && wwc > 0) wsem.release;
mutex.release
}
def endWrite = {
mutex.get;
wc = wc - 1;
if (rwc > 0)
rsem.release
else if (wwc > 0) wsem.release;
mutex.release
}
}
/** A readers/writers lock, using channels, without priortities
*/
class ReadWriteLock3 extends ReadWriteLock {
private val sr = new Signal
private val er = new Signal
private val sw = new Signal
private val ew = new Signal
def startRead = sr.send
def startWrite = sw.send
def endRead = er.send
def endWrite = ew.send
private def rwlock: unit = choice (
sr * (x => reading(1)),
sw * (x => { ew.receive; rwlock })
)
private def reading(n: int): unit = choice (
sr * (x => reading(n+1)),
er * (x => if (n == 1) rwlock else reading(n-1))
)
spawn < rwlock >
}
/** Same, with sequencing
*/
class ReadWriteLock4 extends ReadWriteLock {
private val rwlock = new ReadWriteLock3
private val sr = new Signal
private val ww = new Signal
private val sw = new Signal
def startRead = sr.send
def startWrite = { ww.send; sw.send }
def endRead = rwlock.endRead
def endWrite = rwlock.endWrite
private def queue: unit = choice (
sr * (x => { rwlock.startRead ; queue }),
ww * (x => { rwlock.startWrite; sw.receive; queue })
)
spawn < queue >;
}
/** Readwritelock where writers always have priority over readers
*/
class ReadWriteLock5 extends ReadWriteLock {
private val sr = new Signal
private val er = new Signal
private val ww = new Signal
private val sw = new Signal
private val ew = new Signal
def startRead = sr.send
def startWrite = { ww.send; sw.send }
def endRead = er.send
def endWrite = ew.send
private def Reading(nr: int, nw: int): unit =
if (nr == 0 && nw == 0)
choice (
sr * (x => Reading(1, 0)),
ww * (x => Reading(0, 1))
)
else if (nr == 0 && nw != 0) {
sw.receive;
Writing(nw);
}
else if (nr != 0 && nw == 0)
choice (
sr * (x => Reading(nr + 1, 0)),
er * (x => Reading(nr - 1, 0)),
ww * (x => Reading(nr, 1))
)
else if (nr != 0 && nw != 0)
choice (
ww * (x => Reading(nr, nw + 1)),
er * (x => Reading(nr - 1, nw))
);
private def Writing(nw: int): unit = choice (
ew * (x => Reading(0, nw - 1)),
ww * (x => Writing(nw + 1))
);
spawn < Reading(0, 0) >;
}
/**
* Main function.
*/
def main(args: Array[String]): unit = {
val random = new java.util.Random()
def reader(i: int, rwlock: ReadWriteLock): unit = {
Thread.sleep(1 + random.nextInt(100))
System.err.println("Reader " + i + " wants to read.")
rwlock.startRead
System.err.println("Reader " + i + " is reading.")
Thread.sleep(1 + random.nextInt(100))
rwlock.endRead
System.err.println("Reader " + i + " has read.")
reader(i, rwlock)
}
def writer(i: int, rwlock: ReadWriteLock): unit = {
Thread.sleep(1 + random.nextInt(100))
System.err.println("Writer " + i + " wants to write.")
rwlock.startWrite
System.err.println("Writer " + i + " is writing.")
Thread.sleep(1 + random.nextInt(100))
rwlock.endWrite
System.err.println("Writer " + i + " has written.")
writer(i, rwlock)
}
val n = try { Integer.parseInt(args(0)) } catch { case _ => 0 }
if (n < 1 || 5 < n) {
Console.println("Usage: scala examples.pilib.rwlock <n> (n=1..5)")
exit
}
val rwlock = n match {
case 1 => new ReadWriteLock1
case 2 => new ReadWriteLock2
case 3 => new ReadWriteLock3
case 4 => new ReadWriteLock4
case 5 => new ReadWriteLock5
}
List.range(0, 5) foreach (i => spawn < reader(i, rwlock) >)
List.range(0, 5) foreach (i => spawn < writer(i, rwlock) >)
}
}
