Distributed Object Management

Ideally the DGC should be independent of the object management and the local garbage collector.
A clear interface has been defined for the interaction of the three component.
The DGC must be safe: do not recycle reachable objects.
The DGC should be live: recycle all objects not reachable by the distributed application.

Tasks performed by the manager:

The manager will create an single object of the class DistGC which must perform the distributed garbage collector.
Any time that a process P receives a remote reference not currently present in the object table, the manager will invoke the method sendDirtyCall(wrep) on P. The parameter wrep is the wire representation of reference received.
Any time that a process P detects that a stub is no longer reachable locally, the manager will extract its wire representation wrep from the object table and will invoke the method sendCleanCall(wrep) on P.

Tasks performed by the collector:

Let P be a process where a sendDirtyCall or a sendCleanCall is invoked with a wire representation refering to an object held in Q.
sendDirtyCall(wrep):
- open a socket connection with Q if none is available.
- send (DIRTY, the identifier in wrep) through the socket to notify Q that P references now that object.
cleanDirtyCall(wrep):
- open a socket connection with Q if none is available.
- send (CLEAN, the identifier in wrep) through the socket to notify Q that P no longer references that object.

Each process Q will run a thread for reading dirty and clean message from processes having remote references of objects owned by Q.
This thead must keep for each concrete object the set of spaces which reference that object.
When the procedure clean detects that a concrete object has no remote references then it must invoke the method:
```
  manager.removeFromObjTbl(concNetObj);
```
The manager will extract the concrete object from the object table, so it will be collected if it is not locally reachable.

When the wire representation of a network reference is sent through a socket, it will not arrive immediately.
Flushing the buffer just ensures that the data have been sent, but does not guarant that they have been received.
The references that have been sent but have not being received are named in-transit references.
A race condition occurs when a network object has only in-transit references, because the DGC may incorrectly recycle it.
The proposed implementation does not protect in-transit references to be collected.

Before returning from a remote invocation:

The stub must guarant that all dirty messages corresponding to parameter references have been received.
The stub must guarant that all dirty messages corresponding to the returned value have been received.
clean messages can be sent later.
The easy way to protect in-transit references is sending the dirty calls synchronously.

The current implementation does not collect client/server connections.
It is very import to collect connections, because the threads needed to dispatch remote calls forbid the termination of processes.
Connections can be collected as follows:
- Each object of the class ServerConnection must have a reference counter. That counter will keep the number of references to objects owned by the server process.
- It increases the counter in the method receiveNetObj and decreases the counter in finalizeStub.
- When the counter reaches the value zero, the manager of the client process can close the connection.

A Java process will terminate only when all threads have finished (excepting the daemon threads).
The thread accepting socket connections from the port must be turned to be a daemon thread when there is no exported objects.
A thread dispatching remote calls to local objects will finish when the client side will close the socket, because the reference counter reaches zero.
Thus a process may terminate when there is no exported objects and no remote process has references to local objects.