/** ***********Methods from AltingChannelInput************************* */ /** * Reads an <TT>Object</TT> from the channel. * * @return the object read from the channel. */ public Object read() { /*synchronized*/ lock (rwMonitor) { if (empty) { empty = false; try { Monitor.Wait(rwMonitor); while (!empty) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelRead); } Monitor.Wait(rwMonitor); } } catch (/*InterruptedException*/ ThreadInterruptedException e) { throw new ProcessInterruptedException("*** Thrown from One2OneChannel.read ()\n" + e.ToString()); } } else { empty = true; } spuriousWakeUp = false; Monitor.Pulse(rwMonitor); return(hold); } }
public int startRead() { lock (rwMonitor) { if (data.getState() == ChannelDataStoreState.EMPTY) { try { Monitor.Wait(rwMonitor); while (data.getState() == ChannelDataStoreState.EMPTY) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelXRead); } Monitor.Wait(rwMonitor); } } catch (ThreadInterruptedException�e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannel.read (int)\n" + e.ToString() ); } } return(data.startGet()); } }
public int startRead() { lock (rwMonitor) { if (empty) { empty = false; try { Monitor.Wait(rwMonitor); while (!empty) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelRead); } Monitor.Wait(rwMonitor); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException("*** Thrown from One2OneChannel.read ()\n" + e.ToString()); } } else { empty = true; } return(hold); } }
/** * This process starts, engages in no events, performs no computation * and refuses to terminate. * <p> */ public void run() { Object lockedObject = new Object(); lock (lockedObject) { try { Monitor.Wait(lockedObject); while (true) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.StopRun); } Monitor.Wait(lockedObject); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException("*** Thrown from Stop.run ()\n" + e.ToString()); } } }
/** * Fall into the bucket. * The process doing this will be blocked until the next {@link #flush}. */ public void fallInto() { lock (bucketLock) { nHolding++; // System.out.println ("Bucket.fallInto : " + nHolding); try { int spuriousCycle = bucketCycle; Monitor.Wait(bucketLock); while (spuriousCycle == bucketCycle) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.BucketFallInto); } Monitor.Wait(bucketLock); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException("*** Thrown from Bucket.fallInto ()\n" + e.ToString()); } } }
/*************Methods from ChannelOutput*******************************/ /** * Writes an <TT>Object</TT> to the channel. * * @param value the object to write to the channel. */ public void write(int value) { lock (rwMonitor) { if (isPoisoned()) { throw new PoisonException(poisonStrength); } hold = value; if (empty) { empty = false; if (alt != null) { alt.schedule(); } } else { empty = true; Monitor.Pulse(rwMonitor); } try { Monitor.Wait(rwMonitor); while (spuriousWakeUp && !isPoisoned()) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelWrite); } Monitor.Wait(rwMonitor); } spuriousWakeUp = true; } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannel.write (Object)\n" + e.ToString()); } if (done) { done = false; } else if (isPoisoned()) { throw new PoisonException(poisonStrength); } else { done = true; } } }
/** ***********Methods from AltingChannelInput************************* */ /** * Reads an <TT>Object</TT> from the channel. * * @return the object read from the channel. */ public int read() { lock (rwMonitor) { if (isPoisoned()) { throw new PoisonException(poisonStrength); } if (empty) { empty = false; try { Monitor.Wait(rwMonitor); while (!empty && !isPoisoned()) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelRead); } Monitor.Wait(rwMonitor); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException("*** Thrown from One2OneChannel.read ()\n" + e.ToString()); } } else { empty = true; } spuriousWakeUp = false; if (isPoisoned()) { throw new PoisonException(poisonStrength); } else { done = true; Monitor.Pulse(rwMonitor); return(hold); } } }
/** * Writes an <TT>Object</TT> to the channel. * * @param value the object to write to the channel. */ public void write(int value) { lock (rwMonitor) { //Writer always sees poison: if (isPoisoned()) { throw new PoisonException(poisonStrength); } data.put(value); if (alt != null) { alt.schedule(); } else { Monitor.Pulse(rwMonitor); } if (data.getState() == ChannelDataStoreState.FULL) { try { Monitor.Wait(rwMonitor); while (data.getState() == ChannelDataStoreState.FULL && !isPoisoned()) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelXWrite); } Monitor.Wait(rwMonitor); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannel.write (Object)\n" + e.ToString() ); } if (isPoisoned()) { throw new PoisonException(poisonStrength); } } } }
/** * Writes an <TT>int</TT> to the channel. * * @param value the integer to write to the channel. */ public void write(int value) { //Debug.WriteLine("Int write is " + value); // Debug.WriteLine("Int write hold is " + hold); lock (rwMonitor) { hold = value; if (empty) { empty = false; if (alt != null) { alt.schedule(); } } else { empty = true; Monitor.Pulse(rwMonitor); } try { Monitor.Wait(rwMonitor); while (spuriousWakeUp) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelIntWrite); } Monitor.Wait(rwMonitor); } spuriousWakeUp = true; } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannelInt.write (int)\n" + e.ToString() ); } } }
public int startRead() { lock (rwMonitor) { if (data.getState() == ChannelDataStoreState.EMPTY) { // Reader only sees poison if buffer is empty: if (isPoisoned()) { throw new PoisonException(poisonStrength); } try { Monitor.Wait(rwMonitor); while (data.getState() == ChannelDataStoreState.EMPTY && !isPoisoned()) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelXRead); } Monitor.Wait(rwMonitor); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannel.read (int)\n" + e.ToString() ); } // Reader only sees poison if buffer is empty: if (isPoisoned()) { throw new PoisonException(poisonStrength); } } return(data.startGet()); } }
/*************Methods from ChannelOutput*******************************/ /** * Writes an <TT>Object</TT> to the channel. * * @param value the object to write to the channel. */ public void write(Object value) { /*synchronized*/ lock (rwMonitor) { hold = value; if (empty) { empty = false; if (alternative != null) { alternative.schedule(); } } else { empty = true; Monitor.Pulse(rwMonitor); } try { Monitor.Wait(rwMonitor); while (spuriousWakeUp) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelWrite); } Monitor.Wait(rwMonitor); } spuriousWakeUp = true; } catch (/*InterruptedException*/ ThreadInterruptedException e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannel.write (Object)\n" + e.ToString()); } } }
/** * Synchronise the invoking process on this barrier. * <I>Any</I> process synchronising on this barrier will be blocked until <I>all</I> * processes associated with the barrier have synchronised (or resigned). */ public void sync() { //Debug.WriteLine("Before locking Barrier", "KAROL"); lock (barrierLock) { countDown--; //System.out.println ("CSPBarrier.sync : " + nEnrolled + ", " + countDown); if (countDown > 0) { try { Boolean spuriousCycle = evenOddCycle; Monitor.Wait(barrierLock); while (spuriousCycle == evenOddCycle) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.BarrierSync); } Monitor.Wait(barrierLock); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException( "*** Thrown from CSPBarrier.sync ()\n" + e.ToString() ); } } else { countDown = nEnrolled; evenOddCycle = !evenOddCycle; // to detect spurious wakeups :( //Debug.WriteLine("CSPBarrier.sync : " + nEnrolled + ", " + countDown, "KAROL"); Monitor.PulseAll(barrierLock); } } }
/** * Writes an <TT>int</TT> to the channel. * * @param value the integer to write to the channel. */ public void write(int value) { lock (rwMonitor) { data.put(value); if (alt != null) { alt.schedule(); } else { Monitor.Pulse(rwMonitor); } if (data.getState() == ChannelDataStoreState.FULL) { try { Monitor.Wait(rwMonitor); while (data.getState() == ChannelDataStoreState.FULL) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelIntXWrite); } Monitor.Wait(rwMonitor); } } catch (ThreadInterruptedException�e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannelInt.write (int)\n" + e.ToString() ); } } } }
/**********************************************************************/ /** * Reads an <TT>int</TT> from the channel. * * @return the integer read from the channel. */ public int read() { //Debug.WriteLine("Int read hold is " + hold); lock (rwMonitor) { if (empty) { empty = false; try { Monitor.Wait(rwMonitor); while (!empty) { if (Spurious.logging) { SpuriousLog.record(SpuriousLog.One2OneChannelIntRead); } Monitor.Wait(rwMonitor); } } catch (ThreadInterruptedException e) { throw new ProcessInterruptedException( "*** Thrown from One2OneChannelInt.read ()\n" + e.ToString() ); } } else { empty = true; } spuriousWakeUp = false; Monitor.Pulse(rwMonitor); return(hold); } }