Release History

2005.5.3 Release 1.10

• The JICOS distribution now has 4 parts (please see the Administration/Downloading page for details):
• One for deploying a JICOS system, & developing and running JICOS applications.
• One for system development of JICOS itself.
• One for using JICOS via ant (this is optional), if you do not have ant already running on your system.
• One that has the JICOS web pages.
• Non-Java (External) services: This release supports non-Java clients and services. JICOS Task objects, in principle, now can encapsulate computations that are executed as non-Java code. The Tutorial illustrates the development and use of Matlab as an external service.
• Administrative support: This release is the debut of a tool for administering a JICOS system. The following features are illustrated in the Tutorial:
  
• Starting an entire JICOS service with 1 command via a JICOS configuration file.
  
• Stopping an entire JICOS service with 1 command.
  

• A bug in the fault tolerance code having to do with cached tasks has been fixed.
• A bug in the critical path time computation has been fixed.
• A bug having to do with multiple task servers has been fixed.

2005.1.21 Release 1.9

• The Java source file is prefixed with an open source license.
  
• We added an example of a JICOS client decomposing a computation into pieces, sending each piece to the Hosting Service Provider, getting the results, and assembling them into the overall computational result. This process is illustrated with a matrix product computation.
• The Hosting Service Provider now starts a TaskServer in its JVM. For many deployment scenarios, no other TaskServers need to be started.
• Non-Java clients:
• This is a beta release of functionality to support non-Java clients.
  
• In the programming tutorial, there is a new entry called "External (Non-Java) Clients".
  
• If you play with this functionality, please send us your comments :)
  
• Host registration now is decentralized: Hosts register directly with a task server. Currently, the host provides a list of machine domain names (at least 1). The host joins that task server whose machine name appears first on the list among those that have an RMI registry with a registered TaskServer service.

2003.11.17 Release 1.8

Enhancements

• HspState now includes the hosting service provider's ServiceName. Please see the HspState API and tutorial page.
• Exposed Graph interface and its implementation by GraphImpl and GraphEuclidean. The Graph interface includes 2 methods having to do with maximum matching:
• minCostMaxMatch
• maxCostMaxMatch. 
• The Result class now has a method that returns the critical path time:
long getCriticalPathTime()
A critical directed path is a path of tasks whose execution times sum to a number that is at least as long as any other directed path of tasks. This method returns that time, in milliseconds.
• Task prefetching is now triggered when a task's isAtomic() method evaluates to true. The default implementation of this method evaluates to false. Typing the task class as Atomic now is neither necessary nor sufficient. See the tutorial section on prefetching for details. The API reflects the new Task method. 
• Executing a task on the task server is done when the task is ready to be executed and its executeOnServer method evaluates to true. The default implementation of this method evaluates to false.  Typing the task class as Compose now is neither necessary nor sufficient. Please see the tutorial section on executing tasks on the task server. The API reflects the new Task method.

New Publications

• Ruben Gonzalez Gutierrez. Implementation of Parallel Algorithms in CORBA and JICOS. Degree final project, Escuela Superior de Ingenieria en Informatica, Universidad de Málaga, Spain, June, 2003.
• Peter Cappello. Janet's Abstract Distributed Service Component. Proc. 15th IASTED Int. Conf. on Parallel and Distributed Computing and Systems, pages 751 - 756, Marina del Rey, California, Nov. 2003. (See the Publications page.)
  

2003.9.12 Release 1.7.1

Bugs

• Fixed a bug concerning ComputeException, the exception a client gets when the client application has a task, which when executed throws a runtime exception.

Enhancements

• Exposed via Javadoc our weighted matching class for general graphs whose execution time is O( n³ ), where n is the number of graph vertices. Look in the JICOS package: applications.utilities.graph.
• Added an exception class, called JicosException. If this exception is thrown, an unexpected JICOS runtime exception was thrown - a JICOS bug - which prevents the cleint application from proceeding. The exception is propagated to the client, and thrown on the client's outstanding compute method or getResult method. 

Although this exception handling framework is fairly general, very little of JICOS currently is covered by it. As time permits, more of JICOS will be put under this framework.

2003.9.4 Release 1.7

Changed the name of the system from JICOS to JANET (Java-centric network computing service).

Bugs

• Fixed a bug in the processing of asynchronous compute requests, which was brought to my attention by Michal Sankot, from the Czech Republic.
• Fixed a bug concerning failed hosts: When a host fails, its task server may have RequestTask commands from it, which should be ignored. Michal Sankot also brought this problem to my attention.

Enhancements

• Added a getState method to the Client2Hsp interface, which returns a snapshot of the hosting service provider's state. Please see the API for details. 
• In conjunction with the getState method mentioned above, the API now has an HspState object.
• In conjunction with the HspState object, the API now has a ClientProfile object.
• Multiple clients can login in to an HSP. However, the FIFO processing of clients implies the need to queue client login requests. The HspState object has a queue (Qu object, see API) of ClientProfile objects.

New Publications

• A journal article titled "Advanced eager scheduling for Java-based adaptive parallel computing," to appear in Concurrency and Computation: Practice and Experience. The paper describes Javelin's distributed branch and bound framework, illustrated on the Traveling Salesman Problem, and experiments using 1,000 processors in which good speedup was obtained. This completes our work on Javelin.
• A conference paper titled "Jicos's Abstract Distributed Service Component," describing the object-oriented design of the JICOS foundation layer, on which is built the 3 principal components of JICOS: The Hsp, the TaskServer, and the Host. This paper will appear in the Proc., 15th IASTED Int. Conf. on  Parallel and Distributed Computing and Systems, Nov. 2003.
• Michael O. Neary's Ph.D. dissertation, concerning Javelin, a predecessor to JICOS.

2003.7.25 Release 1.6.1

• Simplified the code that manages the torous of TaskServers.
• Chris Coakley identified and helped me fix serveral bugs associated with the Host:
• When a host has more than 1 available processor:
• a race condition could result in a SetArg Command being executed before the TaskServer was aware of the existence of the Task whose argument was being set.
• Idle time, as had been computed, does not make sense. Rather than track idle time per CommandProcessor thread, it has been omitted from the statistics. It may be reintroduced in the future.
• Made Shared objects immutable.
• Task caching had a bug that caused a marshalling exception (OptionalDataException) under certain circumstances.
• Produced a Java class for Harold Gabow's O( n³ ) implementation of Edmond's weighted maximum matching algorithm. This proved to be more difficult than it sounds. Ed Rothberg's C code for Gabow's implementation mimics the description in Gabow's dissertation. The Java code also mimics the description in Gabow's dissertation (which is to say that it is entirely UNobject-oriented). Where there are discrepencies between the dissertation and the C code, I opted to follow the C code. If you are interested in this Java class, please e-mail me.

2003.5.1 Release 1.6

• The design moved in the direction of supporting an arbitrary graph of TaskServers. However, the current implementation connects the TaskServers as a torous, which eliminates the bandwidth bottleneck associated with the root of the tree topology.
• I re-introduced an asynchronous computing API: the client application now can invoke the setComputation method, whose interface is:
ResultId setComputation( Task )
The method returns immediately with a ResultId that the application caches. The application can subsequently retrieve a result with the getResult method, whose interface is:
Result getResult()
The Result object has 2 components:
• ResultId
• Object - the returned value of the computation.
The application uses the Result's ResultId to associate the Result object's value with the Task whose corresponding setComputation returned that ResultId.

I was persuaded that this asynchronous API should be re-introduced by a private email exchange with Dietmar Lippold. This however is not to say that this API will meet with his approval.

Please see the Programming manual section titled "The non-blocking computation request" for a tutorial introduction to this aspect of the API.

2003.3.27 Release 1.5.4

• The Invoice object now contains Task execution statistics by Task Class, for each Host, TaskServer and Hosting Service Provider. Applications can output this information by invoking the Invoice object's toString method. However, there are accessor methods so that an application can manipulate this data programmatically (e.g., put this data, or some computed function of it, into a database or a spreadsheet). The JICOS API documents what methods are available to effect such manipulation.

 

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Please see the Programming tutorial section devoted to Invoice, to see a simple use of this new Invoice in the Traveling Salesman Problem example.

• The diffusion of unassigned Task objects among TaskServers has been improved significantly (although more will be done).
• The existing design and Java code for JICOS have been simplified.

2003.1.11 Release 1.5.3

• This is a maintenance release, which mostly reflects a refactoring of the foundation package.
• A small change to the BranchAndBound API: The Solution interface's getChildren method returns a Q object,, which is  a LinkedList of Solution objects. The API for the Q class is included in the javadoc.

2002.9.12 Release 1.5.2

Jicos Branch & Bound Framework.

This framework is discussed in the programming tutorial, and applied in the Traveling Salesman Problem part of the tutorial. It greatly simplifies implementing branch and bound search applications in Jicos.

Explicit task prefetching

In order to implement the branch & bound framework in a manner that performs well for all such applications, explicit task prefetching is introduced into the API (an Environment method). This issue is discussed in the section of the programming tutorial devoted to the Branch and Bound framework. Task prefetching can be invoked from within any Task, although it generally is not necessary to do so. See the section of the tutorial on Performance.

2002.9.1: Release 1.5.1

• the bug where the TaskServer main method ignores the command line argument indicating how many Host objects to instantiate.
• an apparant bug that caused a NullPointerException (this matter will be looked into more deeply).

2002.8.29: Release 1.5

• A standalone Jicos environment can be constructed within an application's JVM. Please see the programming tutorial.
• When a Host is constructed, it determines the number of processors available to its JVM, and starts that many Processor objects - threads that request & process Task objects. Thus, a Host instantiated on a quad-processor workstation, for example, would start 4 Processor threads. This is more efficient than starting 4 Hosts on 4 separate JVMs.
• The Hsp now has 2 optional command-line arguments: 
1. the number of TaskServer objects to be started on the same machine (default = 0)
2. the number of Host objects to be started on the same machine (default = 0).
This feature is envisioned merely to easily create a non-trivial HSP for testing.
• The TaskServer now has 1 optional command-line argument: the number of Host objects to be started on the same machine (default = 0).

2002.8.27: Release 1.4.2

The most reasonable way I could see to do this involves getStackTrace and setStackTrace, Throwable methods that are available only in JDK 1.4 and later: 

Jicos 1.4.2 thus requires a runtime environment of JDK 1.4.*.

2002.8.26: Release 1.4.1

2002.8.24: Release 1.4

API

The Task execute method no longer takes a Host as an argument. A Task learns of its computational environment exclusively via the Environment argument.

There is a new Task subclass: Atomic, used for application-directed Task prefetching. Please see API & the programming tutorial.

There are a few application utility classes: AddInteger, MinIntegerSolution, and IntUpperBound. See the API & the programming tutorial.

The system incorporates 3 new features that serve to materially reduce the communication overhead:

Task caching
Tasks that generate subtasks with the Task compute method will have their 1st child cached on the Host that generated them.
Task prefetching
Tasks that are typed Atomic trigger their Host to initiate a Task prefectch before invoking the Atomic task's execute method.
TaskServer evaluation

Selected tasks have their execute method invoked on the TaskServer itself, rather than shipping it to a Host for execution. Currently, there are only 2 such Task classes AddInteger & MinIntegerSolution. Others will be added, but the system currently does not allow an arbitrary task to be executed on the TaskServer.

2002.8.20: Release 1.3.1.1

Maintenance release: This release removes the System.exit(1) statements from the catch clauses of RemotException. These were inadvertantly left in from system test, and cause the system to terminate when a RemoteException is caught (which is wrong for production, when, for example, a Host fails).

2002.8.16: Release 1.3.1

The essential feature of this release is that the Jicos system has been redesigned into a 2-layer architecture: 

foundation

contains the classes needed to make a distributed system in Java;

services

contains the classes needed to implement the Jicos Hsp, TaskServer, & Host, all in terms of foundation classes.

2001.11.12: Release 1.3

The principal improvement is a simplification of the API, principally task construction. These improvements are illustrated in the Programming Manual.

A minor change concerns some component name changes: Please see the System Administration Manual.

2001.10.29: Release 1.2

The principal improvement is the implementation of a network of task servers. Prior releases supported just 1 task server, although the designof Jicos always had this network. Jicos support for hosts now scales, in principle, to an arbitrarily large set.

• A minor change: the HSPAgent class's getNetwork method is now named getHSP.

2001.9.30: Release 1.1.1

The principal improvements are:

• Some renaming of components: 
• Producer has been renamed Host
• ProductionNetwork has been named HSP (meaning Hosting Service Provider).
• A simpler API: A task's execute method now is passed only a reference to its Host. All Remote method invocations that used to be on the TaskServer have been replaced with local method invocations on the Host. These changes make for shorter, clearer, simpler applications.

2001.9.8: Release 1.1

The principal improvements are:

• A simpler task construction API.
The ability to use a weakly shared mutable object among all the tasks of a computation. The tutorial gives an example of this feature: a branch and bound application for solving the Traveling Salesman Problem.

2001.8.17: Release 1.0

The initial release of Jicos.