In a volunteer-based Grid, the system must be heterogeneous, and the computation capability of each node varies, and load distribution or load balancing is one of the most important issues in Grid. Some techniques have been proposed for dynamic load distribution which relocates jobs, by migrating running jobs keeping their execution states, from a high-loaded node to a lower-loaded node during execution. In this paper, we propose a dynamic load distribution between computation nodes using mobile threads which leads to lightweight, low-overhead job relocation. We present its effects using an example problem, parallel Prefix Span used in analysis of amino-acid sequences, whose computation cost is absolutely unpredictable.

Applying design patterns to the design of an application makes it robust against issues related to extensibility and maintainability. However, currently, a designer must apply structures and constraints of design patterns to an application by hand, therefore mistakes often occur. We have proposed a notation using SGML for describing design patterns and a support system for design patterns. We aim at providing a source code generation support system based on the notation and system. There has been much research into semi-automatic application generators using existing knowledge such as libraries based on algorithms and data structure, and classes packaged based on the object-oriented technology. When using design patterns for source code generation support, the same requirements for such semi-automatic application generators must be considered. The requirements are lessening codes to be written by users, and satisfying constraints without directing users' attention to them. In this paper we consider the requirements and describe a design and implementation of the source code generation support system and results.

Design patterns are abstract software components for system structures and functions used in OOA/OOD. They are described currently as texts (with figures), and difficult to catalog, maintain and handle. The paper presents a framework to describe patterns as structured documents based on SGML (Structured Generalized Markup Language). A design pattern, in general, has three elements: texts, configuration charts and pseudo-codes, therefore SGML schemes are proposed for them respectively so that they are integrated into a single structured document. The document also includes link to related pattern documents and corresponding class source codes. This SGML-based pattern document is visualized by automatic HTML conversion and automatic chart generation. And the document is used for interactive code generation.

Modeling environment is essential for agents to cooperate with each other in a distributed system. In this paper, we propose two strategies for selecting agents’ communication structures in a cooperative search using their local histories as a model of their computational environment. Under the assumption of homogeneity of agents, an agent can select a proper communication structure by using a history of local computation, and the utility of communication always matches its cost. Simulations using the traveling salesman problem show that strategies produce high performance. We also describe an extension of these strategies to other areas and the means to separate them from application programs using meta-object programming in Object-Oriented Programming Languages (OOPL).

A cooperative computation model, Cellula, is presented. It is aimed at establishing a design framework for complex distributed systems. It is designed to organize many autonomous individuals into a group and to coordinate them or make them cooperate. Cellula has two principal components: a cell for group abstraction and a tuple (keyed-value) for pattern-directed communication. The structure of Cellula is quite simple, but some examples show that it can describe in a straightforward manner several styles of coordinated and cooperative computation required in complex distributed systems and autonomous decentralized systems.>

In this paper, we describe a purely object-oriented framework of pattern recognition systems. Its aim is in dealing with knowledge representation issues in pattern recognition. In our approach, everything works in an entirely autonomous and decentralized manner. Even a search procedure for sample-concept matching is distributed onto every concept object itself by being implemented in what we introduced as the recursive agent-blackboard model. We developed an experimental prototype of character recognition systems in Smalltalk-80, which proved the ability of the object-oriented framework and the cooperative search procedure.

An approach to the derivation of hardware algorithms from recurrence equations is proposed that is based on program transformation. A representation for hardware algorithms, called relational representation, is introduced, in which one relational program corresponding to a given recurrence equation (namely a specification) is transformed to another relational program corresponding to a hardware algorithm (namely an implementation). Based on the unfold/fold transformation method of logic programs, several transformation tactics have been formalized. Several implementations of hardware algorithms, such as pipelines, orthogonal grids, and trees, have been derived from their respective specifications in recurrence equations.>