All Packages  This Package  Class Hierarchy  Class Search  Index

java.lang.Object
   |
   +----utah.npm.core.ThreadIPC

Summary

final class  ThreadIPC
     extends java.lang.Object
{
          // Fields 32
     private static final boolean AM_RECEIVER;
     private static final boolean AM_SENDER;
     static final byte IPC_OP_ACK;
     static final byte IPC_OP_CONNECT;
     private static final byte IPC_OP_INVALID;
     static final byte IPC_OP_OVER;
     static final byte IPC_OP_RECV;
     static final byte IPC_OP_REPLY;
     static final byte IPC_OP_SEND;
     static final byte IPC_OP_WAIT;
     static final int RC_DISCONNECTED;
     static final int RC_INVALIDDEST;
     static final int RC_MOREDATA;
     static final int RC_MOREOBJS;
     static final int RC_MOREREFS;
     static final int RC_OK;
     static final int RC_RESTART;
     private final Link clientLink_;
     private byte clientOps_;
     IPCPayload clientPayload_;
     Object clientPortAlias_;
     PortSet clientPortSet_;
     private boolean clientSendTo_;
     private Thread client_;
     private Thread psetQueue_;
     private final Link serverLink_;
     private byte serverOps_;
     IPCPayload serverPayload_;
     Object serverPortAlias_;
     PortSet serverPortSet_;
     private boolean serverSendTo_;
     private Thread server_;

          // Constructors 1
     ThreadIPC();

          // Methods 24
     int clientAlert(Thread);
     int clientConnect(Thread);
     void clientDisconnectServer(Thread);
     int clientFindServer(Thread, boolean);
     int clientOps(Thread, IPCPayload, int);
     int clientReliableTransfer(Thread, Thread, IPCPayload, IPCPayload);
     int clientReverseConnection(Thread, Thread);
     String debugInfo();
     void destroy();
     boolean getClient(Link);
     boolean getServer(Link);
     void makeDormant(Thread, Thread);
     void makeLive(Thread, Thread);
     Thread s_psetDequeue();
     void s_psetEnqueue(Thread);
     int serverAlert(Thread);
     int serverConnect(Thread);
     void serverDisconnectClient(Thread);
     int serverFindClient(Thread, boolean);
     int serverOps(Thread, IPCPayload, int);
     int serverReliableTransfer(Thread, Thread, IPCPayload, IPCPayload);
     int serverReverseConnection(Thread, Thread);
     void setClient(Link, boolean);
     void setServer(Link, boolean);
}

The thread-specific IPC state and all of the methods for manipulating that state (basically, everything to with IPC.) Users of the NPM package see the IPC API through IPC.class. That class establishes a connection between two threads, this class implements the connection between two threads.

Instances of this class are visible to arbitrary subclasses of Thread, and so *all* data members and member functions must be either private or package-access only.

Version:

NPMJava 0.5.0 April, 1998

Author:

Patrick Tullmann tullmann@cs.utah.edu

See Also: IPC, Thread

Fields

· IPC_OP_CONNECT

Summary  |  Top

   static final byte IPC_OP_CONNECT

   static final byte IPC_OP_ACK

   static final byte IPC_OP_SEND

   static final byte IPC_OP_WAIT

   static final byte IPC_OP_OVER

   static final byte IPC_OP_RECV

   static final byte IPC_OP_REPLY

   private static final byte IPC_OP_INVALID

   static final int RC_OK

Return code used by all integer-returning functions. Indicates success.

   static final int RC_RESTART

Return code used to indicate that the clientOps()/serverOps() function should be restarted (usually indicated that the caller was put to sleep and when it awakes, the other half may have completed a big chunk of the operation. This code is never returned to the "user".

   static final int RC_DISCONNECTED

Return code indicating that the connection has been terminated, the caller receiving this code should clean up and exit.

   static final int RC_INVALIDDEST

Return code indicating that the destination the thread was trying to connect to has gone stale.

   static final int RC_MOREDATA

Return code used to indicate that the receiver should try to recieve more data (all of the sender's data didn't fit in the provided buffers).

   static final int RC_MOREREFS

Return code used to indicate that the receiver should try to recieve more references (all of the sender's references didn't fit in the provided buffers).

   static final int RC_MOREOBJS

Return code used to indicate that the receiver should try to recieve more objects (all of the sender's objects didn't fit in the provided buffers).

   private Thread client_

If connection is "live" this will point directly to the client thread. If the connection is "dormant" or doesn't exist at all this will be null.

   private final Link clientLink_

If a connection is "live", this link is invalid (there is always a link object here, but it may or may not point to something.) If the connection is "dormant" this link points to the client thread. If there is no connection, this link is null.

   private boolean clientSendTo_

clientSendTo_ indicates what direction this thread is communicating in with its client (sending or receiving.)

   private static final boolean AM_SENDER

   private static final boolean AM_RECEIVER

   private byte clientOps_

The set of ops we're executing as a client, e.g., on our server link. This is visible so that our server may modify it, as it completes operations for us...

   IPCPayload serverPayload_

The payload structure to use when this thread is the "server".

   Object clientPortAlias_

The alias associated with the port the server's current client used. This is for passing the alias info out to the server IPC layer.

   PortSet clientPortSet_

The port set the server should block on when doing a waitReceive. This gets set in serverSetup, and should stay constant until the next setup.

   private Thread server_

Same as client_ (above) but for the server.

   private final Link serverLink_

Same as clientLink_ (above) but for the server.

   private boolean serverSendTo_

Same as clientSendTo_ (above) but for the server.

   PortSet serverPortSet_

Port set to look for a server on. This is, effectively, the Port Ref pararmeter passed into clientConnect*().

   Object serverPortAlias_

Alias of the port client connected through, this is copied over into the clientPortAlias_ when a connection is set up between a client and a server.

   IPCPayload clientPayload_

The payload structure to use when this thread is the "client".

   private byte serverOps_

The set of ops we're executing as a server. This is visible so that our client may modify it, as it completes operations for us...

   private Thread psetQueue_

The next thread in the queue of threads waiting on a particular PortSet.

See Also: PortSet, PortSet.s_waitForServerThread, PortSet.s_captureServerThread, PortSet.s_waitForClientThread, PortSet.s_captureClientThread

Constructors

· ThreadIPC

Summary  |  Top

   ThreadIPC() 

   void makeDormant(Thread client, 
                    Thread server) 

Make an existing, "live" connection a "dormant" one. It is always the case that the client or the server is captured by the other. Which is which is not important.

Parameter	Description
client	the Client of the connection.
server	the Server of the connection.

   void makeLive(Thread client, 
                 Thread server) 

Make an existing "dormant" conneciton "live." It is always the case that the client or the server is captured by the other.

Parameter	Description
client	the Client of the connection.
server	the Server of the connection.

   int clientReverseConnection(Thread client, 
                               Thread server) 

Reverse the direction of the current connection. Assumes client is the current thread (though it may be either sending or receiving.)

If the client is the sender, then it had best be trying to do an 'OVER'. If the client is the receiver then it has best be trying to do an 'ACK'. If the server is not waiting in the required state IPC_SR_ACK, or IPC_SR_OVER (respectively) then the client will block in IPC_CL_OVER or IPC_CL_ACK (respectively.)

Parameter	Description
client	the current thread, acting as a client
server	the server thread for this client's connection

Returns:

a standard integer status return code

   int clientReliableTransfer(Thread client, 
                              Thread server, 
                              IPCPayload from, 
                              IPCPayload to) 

Make a reliable IPC transfer between client and server, where the client is the currently running thread (and the server is "captured.")

Java-based IPC has the interesting property that the sender can never fault during the transfer. Really. Never. Makes this code much simpler.

Parameter	Description
client	the current thread and the client in the connection
server	the server in the connection
from	the source payload (might be either client or server!)
to	the destination payload

Returns:

a standard integer status reture code

See Also: IPCPayload.tansfer

   int clientFindServer(Thread client, 
                        boolean expectSendTo) 

"Find" the server thread for the client's current server connection. This function assumes a connection has already been established and that it is probably "dormant." The connection is made "live." The server_ variable is set if the server is found, otherwise it is null'd. Returns RC_OK if everything is okay, otherwise returns an appropriate non-zero error---which in all cases means disconnect.

Parameter	Description
client	The client thread (current thread)
expectSendTo	true if the client is expected to be the sender

Returns:

RC_OK if server was found, error code otherwise.

   void clientDisconnectServer(Thread client) 

Disconnect from server (client is caller.) Since client thread is not captured---its running---the link must be "dormant", if it exists at all. State of the server is therefore unknown. (Clients never issue a "connect" in the middle of a multi-part IPC operation, as opposed to servers which can initiate a "wait" in the middle of a multi-sequence operation.)

Parameter	Description
client	the current thread, the client

See Also: IPC.clientDisconnect, ThreadIPC.serverDisconnectClient

   int clientAlert(Thread client) 

Send a alert to this thread's server (the current thread is the client.)

Parameter	Description
client	the current thread acting as a client

Returns:

an standard integer status return code.

   int clientConnect(Thread client) 

Connect the given client to some server on serverPortSet_. If no server is available, the client will be blocked in IPC_CL_CONNECT. If a server is available, that server will be captured, and links between client and server will be made "live" (direct.) If the client blocks, when it wakes, it may have been captured by the server which might have completed all the client's operations for it.

Sets the server_ member variable.

Parameter	Description
client	the client thread (also the current thread)

Returns:

RC_OK if the client should proceed (it didn't block), some other return code if the client was blocked and potentially captured.

   int clientOps(Thread client, 
                 IPCPayload payload, 
                 int initialOps) 

   void setClient(Link newlink, 
                  boolean sendTo) 

   boolean getClient(Link link) 

   int serverReverseConnection(Thread server, 
                               Thread client) 

   void serverDisconnectClient(Thread server) 

   int serverAlert(Thread server) 

   int serverReliableTransfer(Thread server, 
                              Thread client, 
                              IPCPayload from, 
                              IPCPayload to) 

   int serverFindClient(Thread server, 
                        boolean expectSendTo) 

   int serverConnect(Thread server) 

   int serverOps(Thread server, 
                 IPCPayload payload, 
                 int initialOps) 

   void setServer(Link newlink, 
                  boolean sendTo) 

   boolean getServer(Link link) 

   void s_psetEnqueue(Thread next) 

   Thread s_psetDequeue() 

   void destroy() 

   String debugInfo() 

All Packages  This Package  Class Hierarchy  Class Search  Index