Tsutomu Yoshinaga

A parallel object-oriented total architecture: A–NET

A-NET is a parallel object-oriented total architecture for highly parallel computation. Starting with a computation model, the authors describe parallel constructs of the designed language, called A-NETL; the A-NETL-oriented machine instruction set architecture; the hardware organization of a node processor, which consists of a 40-bit processing element and a router; and a local operating system on each of the node processors. Statistics for the designed language and the machine are derived from experimental results.<<ETX>>

A network-topology independent task allocation strategy for parallel computers

For mapping a task graph to a processor graph, this strategy evaluates several functions that represent some intuitively feasible properties of the graphs. Several strategies are defined to guide the mapping process, utilizing the indicated values. An allocation system has been designed and implemented based on this strategy. The experimental results indicate the following: the system can yield 2.14 times better allocation than an arbitrary allocation; it is difficult to select a single strategy capable of providing the best solutions for a wide range of task-processor combinations; and the computation time of the allocator is reasonable. The effect of task and processor topology combinations on the allocation results is also discussed.<<ETX>>

A-NETL: a language for massively parallel object-oriented computing

A-NETL is a parallel object-oriented language intended to be used for managing small to massive parallelism with medium grain size. Its design goals are to support various styles of message passing, to treat data parallel operations at the same cost as programming languages of the SIMD type, to provide several synchronization facilities for autonomous control, and to provide information for the efficient allocation of objects to nodes. Starting with these design principles, this paper then goes on, to describe the syntax and semantics of the language and the major implementation issues, including the reduction of message communication cost, efficient implementation of statically and dynamically created massive objects, the realization of synchronization schemes, the object-to-node allocation scheme to minimize communication cost, and logical-time-based debugging for asynchronous operations.

A parallel object-oriented language A-NETL and its programming environment

A description is presented of the design principles and features of the A-NETL, a language for describing highly parallel programs. The authors explain the features by using an example program. They also refer to its programming environment, which includes a multiwindow-based programming support system, language processors, and a debugger.<<ETX>>

A cost and performance comparison for wormhole routers based on HDL designs

Our research investigates cost and performance characteristics for wormhole routers based on HDL designs. Comparison for dimension order routers and turn model based adaptive routers leads to the following conclusions: (1) static and additional routing information which we propose, such as prior dimension specification and in-order delivery, improves the communication performance; (2) an adaptive routing algorithm must be implemented to satisfy the objective speed of the design (the operation speed of the routers significantly affects the network performance); (3) the virtual channels cancel the improvement not only for the dimension order router but also for the naive implementation of the adaptive routers when they degrade the operation speed.

Programming and Debugging for Massively Parallelism: The Case for a Parallel Object-Oriented Language A-NETL

This paper describes the two major issues of programming and debugging with a parallel object-oriented language, A-NETL. A-NETL programming is supported by several language facilities, such as the static definition and dynamic creation of massively parallel objects, asynchronous message passing of past, now, and future types and their multicast versions, and declarative synchronization schemes. A-NETL debugging requires special support for verifying the behavior of asynchronous operations. The major feature of the A-NETL debugger is the utilization of logical time, based on the ”happened before” relation among events. During a test execution, the events and their logical time are recorded as an event history. The history is edited and presented to the user to provide a global view of the execution. The history is also utilized at the replay phase to provide a virtual event-level clock to a multicomputer and to keep the happened-before relation at test execution time. This not only enables cyclic debugging but also simplifies debugging by showing originally asynchronous operations synchronously.

Parallel Navigation in an A-NETL Based Parallel OODBMS

A parallel OODBMS has been proposed based on a parallel object-oriented language, A-NETL. The OODBMS is designed for a shared-nothing environment. An overview of the database system is described. Accessing object-data in a parallel OODBMS is based on navigation. A parallel navigation algorithm being implemented for use in the system is presented including its features. The algorithm is based on the need to balance the load across all nodes in a parallel OODB accessing objects with set-valued attributes. An analytical evaluation of the features of the algorithm is presented.

Node processor for a parallel object-oriented total architecture A-NET

A-NET is a parallel object-oriented total architecture for highly parallel computation. Starting with a computation model, this paper describes parallel constructs of the designed language, called A-NETL; the A-NETL oriented machine instruction set architecture; the hardware organization of a node processor, which consists of a 40-bit processing element and a router; and a local operating system on each of the node processors. Statistics for the designed language and the machine are derived from experimental results. Keywords: parallel object-oriented, total architecture, multicomputer, processing element, router, parallel operating system

Recover-x: an adaptive router with limited escape channels

In order to improve network performance, a variety of adaptive routing algorithms have been proposed. Recent research focuses on their implementation costs, as well as the performance to enhance their practical applications. The paper proposes the Recover-x adaptive router, which limits escape message candidate in a blocked or deadlocked configuration. This limitation simplifies the routing logic and offers a chance to balance the usage between adaptive and non-adaptive channels. The cost and performance of four wormhole routers based on Verilog-HDL designs were compared. Synthesis results for the chosen gate array technology show that the Recover-x router attains a fast operating speed and low-latency, with high-bandwidth communication performance.

Event-based debugging system for a parallel object-oriented language A-NETL

Debugging of parallel programs is generally very difficult to undertake since the execution of programs is nondeterministic and nonrepeatable. Considering a parallel object-oriented language, this paper proposes a method of preserving the repeatability of the order of execution in a replay by defining a logic time in terms of events in the message communication system and state transitions, and by representing the execution history of events. A debugger that mainly uses a two-dimensional (2-D) representation and replay debugging has been designed based on the proposed method. A high-performance system has been constructed based on the design. The debugger functions are distributed between a host workstation and multicomputer nodes, and between local OS on nodes and in firmware so that a high-performance system has been realized. The experiments show that the method is successful for practical applications; the time and space overhead of event recording is 0.04 ms (mean value) and 35 B per event, respectively; the display of 16 objects for one logical time is 0.94 s; and the overhead for a breakpoint is 3.1 ms per point.