See: Description
| Interface | Description |
|---|---|
| BundleManager |
Methods for bundle management.
|
| HandleCallback |
Callback handler interface.
|
| IntermediateResultHandler |
Intermediate result handler interface.
|
| PasswordDialog |
Interface for providers implementing password dialog.
|
| Peach |
Peach Interface.
|
| ProjectManager |
Methods for project management.
|
| ReportManager |
Report Manager interface.
|
| ResultManager |
Methods for project result management, like downloading and unzipping.
|
| SemaphoreManager |
Semaphore Manager interface.
|
| StatusWindow |
Status Window interface.
|
| Support |
Support interface contains status codes and their explanations.
|
| TechilaExecutorServiceCallback<T> |
Callbacks for Techila Executor Service.
|
| TechilaManager |
The main Techila Manager interface.
|
| UserManager |
User Manager Interface.
|
| WorkerManager |
Worker Manager Interface.
|
| Class | Description |
|---|---|
| Configuration |
Techila Configuration class.
|
| Handle |
Handle object for storing state information.
|
| PeachWrapper |
Wrapper class for C style Peach calls.
|
| TechilaExecutorCompletionService<T,V> |
TechilaExecutorCompletionService.
|
| TechilaExecutorService<T> |
TechilaExecutorService.
|
| TechilaFutureTask<T> |
TechilaFutureTask.
|
| TechilaManagerFactory |
Factory for creating a TechilaManager instance.
Example:
TechilaManager techila = TechilaManagerFactory.getTechilaManager(); |
| Enum | Description |
|---|---|
| Handle.HandleCallbackType |
| Exception | Description |
|---|---|
| TechilaException |
Exception class.
|
Each individual calculation run in the Techila system is called a project. A project contains the information of the databundle which is required to run the project. Each databundle in turn contains the information about the binary bundle (executor) (in some cases the databundle and binary bundle may be the same bundle).
Each project consist of jobs. A job is run on the client machine in one cpu core (a multi-core machine can run multiple jobs simultaneously). A job contains parameters for one run with the executable.
Normally the jobs in the project are created on the server using a splitter. The splitter takes the project parameters and creates individual jobs based on them. It is also possible to create jobs directly using the interface.
A Job usually creates a result file which is then transmitted to the server. When the project is finished all the results are put together into a zip-file. This zip-file can then be downloaded and unzipped. After that the processing of the resulting files is specific to the calculation.
Each user of the interface needs to create a private and public key pair for him/herself. These can be created with the provided keytool.jar (or the Sun keytool can also be used). The Techila Administrator needs to sign the user certificate before it can be used for code signing.
A handle is an object for storing related information about a project.
With handles it is possible to run multiple projects simultaneously
within on instance of the management library. Normally the library
user only sees the integer index of the handle (returner by
open() method).
The package is divided into several interfaces, each of them
describes a subset of the methods which are available for commanding
the Techila system. The TechilaManager interface is the
main interface,
it has methods for getting the other interfaces. An implementing
instance of the main TechilaManager interface can be obtained with the
static getTechilaManager method in the
TechilaManagerFactory class.
Example:
TechilaManager techila = TechilaManagerFactory.getTechilaManager();
The simplest way to run a Java based project with Techila is to use the
Peach interface. Detailed examples can be found from the
examples/java directory
included in the Techila SDK.
The library is written in Java, but there are wrappers around it for use from other languages like C and Fortran. Therefore the methods usually return integer error codes instead of throwing an exception.