[e-cvs] cvs commit: e/src/jsrc/org/erights/e/elib/ref DeviceRef.java

[markm@eros.cs.jhu.edu]

markm       01/08/28 17:01:31

  Modified:    src/jsrc/org/erights/e/elib/io ReaderWrapper.java
               src/jsrc/org/erights/e/elib/prim Queue.java SynchQueue.java
               src/jsrc/org/erights/e/elib/ref DeviceRef.java
  Log:
  progress towards asynch reader

Revision  Changes    Path
1.2       +8 -6      e/src/jsrc/org/erights/e/elib/io/ReaderWrapper.java

Index: ReaderWrapper.java
===================================================================
RCS file: /cvs/e/src/jsrc/org/erights/e/elib/io/ReaderWrapper.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- ReaderWrapper.java	2001/08/28 06:40:10	1.1
+++ ReaderWrapper.java	2001/08/28 21:01:31	1.2
@@ -40,7 +40,8 @@
     
     private Reader myWrapped;
     
-    private Object myQLock;
+    /** A prompt lock shared with the SynchQueue */
+    private Object myLock;
     
     private SynchQueue myAsynchRequests;
     
@@ -59,8 +60,9 @@
     /** Assumes it has exclusive access to 'wrapped' */
     public ReaderWrapper(Reader wrapped) {
         myWrapped = wrapped;
-        myQLock = new Object();
-        myAsynchRequests = new SynchQueue(Message.class, myQLock);
+        myLock = new Object();
+        myAsynchRequests = new SynchQueue(Message.class, myLock);
+        myOptMsg = null;
         myCreator = Runner.currentRunner();
         myReadingThread = new Thread(this, "ReaderWrapper");
         myReadingThread.start();
@@ -72,9 +74,9 @@
     public void run() {
         while (true) {
             // If blocked on dequeue, myOptMsg will be null
-            synchronized (myQLock) {
+            synchronized (myLock) {
                 myOptMsg = null;
-                //ensure assignment happens while still holding myQLock
+                //ensure assignment happens while still holding myLock
                 myOptMsg = (Message)myAsynchRequests.dequeue();
             }
             // Using E.call(..) in a non-vat thread!
@@ -93,7 +95,7 @@
      * wrapped Reader is ready, then we're ready
      */
     public boolean ready() throws IOException {
-        synchronized (myQLock) {
+        synchronized (myLock) {
             return myOptMsg == null && 
                    ! myAsynchRequests.hasMoreElements() &&
                    myWrapped.ready();



1.7       +0 -2      e/src/jsrc/org/erights/e/elib/prim/Queue.java

Index: Queue.java
===================================================================
RCS file: /cvs/e/src/jsrc/org/erights/e/elib/prim/Queue.java,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -r1.6 -r1.7
--- Queue.java	2001/08/20 05:07:44	1.6
+++ Queue.java	2001/08/28 21:01:31	1.7
@@ -121,8 +121,6 @@
      * @return is false if the queue is empty, otherwise true
      */
     public boolean hasMoreElements() {
-        //NOTE: This depends on the java & jvm guarantee that int read
-        //and write is atomic.
         return myCurSize != 0;
     }
 



1.2       +24 -5     e/src/jsrc/org/erights/e/elib/prim/SynchQueue.java

Index: SynchQueue.java
===================================================================
RCS file: /cvs/e/src/jsrc/org/erights/e/elib/prim/SynchQueue.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -r1.1 -r1.2
--- SynchQueue.java	2001/08/24 17:14:02	1.1
+++ SynchQueue.java	2001/08/28 21:01:31	1.2
@@ -41,7 +41,7 @@
      * Makes a SynchQueue that can hold any object (except null).
      */
     public SynchQueue() {
-        this(Object.class);
+        this(Object.class, new Object());
     }
 
     /**
@@ -50,8 +50,15 @@
      * @param elementType may not be a primitive (ie, scalar) type.
      */
     public SynchQueue(Class elementType) {
+        this(elementType, new Object());
+    }
+
+    /**
+     * Provide the object to lock on.
+     */
+    public SynchQueue(Class elementType, Object qLock) {
         super(elementType);
-        myQLock = new Object();
+        myQLock = qLock;
     }
 
     /**
@@ -60,7 +67,7 @@
      * dequeued. 
      */
     public Object dequeue() {
-        synchronized(myQLock) {
+        synchronized (myQLock) {
             while(true) {
                 Object result = optDequeue();
                 if (result != null) {
@@ -80,17 +87,29 @@
      * 
      */
     public void enqueue(Object newElement) {
-        synchronized(myQLock) {
+        synchronized (myQLock) {
             super.enqueue(newElement);
             myQLock.notifyAll();
         }
     }
 
     /**
+     * Check to see if the queue has more elements.  This method
+     * allows a Queue to be used as an Enumeration.
+     *
+     * @return is false if the queue is empty, otherwise true
+     */
+    public boolean hasMoreElements() {
+        synchronized (myQLock) {
+            return super.hasMoreElements();
+        }
+    }
+
+    /**
      * 
      */
     public Object optDequeue() {
-        synchronized(myQLock) {
+        synchronized (myQLock) {
             return super.optDequeue();
         }
     }



1.5       +1 -1      e/src/jsrc/org/erights/e/elib/ref/DeviceRef.java

Index: DeviceRef.java
===================================================================
RCS file: /cvs/e/src/jsrc/org/erights/e/elib/ref/DeviceRef.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -r1.4 -r1.5
--- DeviceRef.java	2001/04/13 08:08:34	1.4
+++ DeviceRef.java	2001/08/28 21:01:31	1.5
@@ -33,7 +33,7 @@
  * The arguments passed in must be objects that may validly be used from
  * multiple vats at once, such as transitively pass-by-copy objects, or
  * further DeviceRefs.  This constraint is not enforced, so only trusted code
- * may hold DeviceRefs.  Messaes sent over DeviceRefs return a DeviceRef for
+ * may hold DeviceRefs.  Messages sent over DeviceRefs return a DeviceRef for
  * designating a return result in the target's vat.
  *
  * Even if the target is or becomes BROKEN or PassByConstruction, DeviceRef