Larry D. Wittie

Multicast Communication on Network Computers

Channel-oriented packet casting is a predominant feature of Micros, an operating system designed to explore control and communication techniques for network computers containing thousands of hosts.

Debugging distributed C programs by real time reply

Bugnet is a portable Unix system designed to debug C programs distributed within a local area network. A graphics interface allows the user of a Sun workstation to manage process groups and monitor process interactions very conveniently. Bugnet gives information about interprocess communication, I/O events, and execution traces for each component process. It allows the user to detect an error visually, to roll global program state back to a time before the error, and to replay events almost exactly as they previously occurred. Current work on Bugnet is making the implementation easier to port, seeing if replay accuracy can be improved by minor adjustments in the Unix process scheduler, linking it with Unix dbx to control individual processes, and determining useful tools for filtering of long event strings and for detecting errors. The Bugnet project is testing how well existing multiprocess C programs can be debugged without special hardware features that make porting difficult. An initial version is running on a network of Suns. It currently reproduces real time execution sequences with an accuracy of 0.01 to 0.10 seconds.

Optimistic synchronization in distributed shared memory

Introduces optimistic lock synchronization using the group write consistency (GWC) model. GWC guarantees strict ordering of all shared writes in a processor group. In optimistic synchronization, if a lock-requesting processor can assume that the lock is free, execution of mutually exclusive code starts immediately. A wrong assumption results in rollback. Shared variable updates remain in the group until the lock manager grants the lock to the requesting processor. By evaluating the time needed for three processors to execute mutually exclusive code, GWC can out-perform weak, release, and even entry consistency. Simulations of task management using exclusive access to a shared queue, also show much faster mutual exclusion with GWC. Optimistic mutual exclusion may further halve total delays in accessing shared resources.<<ETX>>

The Bugnet distributed debugging system

Distributed debugging via serial debuggers suffers from two problems: i. serial debuggers are made for one process running on a single processor, whereas distributed programs contain many processes running on different processors in a network. 2. the sequence of events that lead to an error in a distributed program can be quite complex to model and difficult to capture and recreate using a serial debugger. A true distributed debugger should handle both problems easily.

Global Naming in Distributed Systems

This Unix-based global naming system, developed for debugging distributed programs, provides concise notation for accessing networks, tasks, modules, data, and files.

Fast locks in distributed shared memory systems

Synchronization and remote memory access delays cause staggering inefficiency in most shared memory programs if run on thousands of processors. The authors introduce efficient lock synchronization using the combination of group write consistency, which guarantees write ordering within groups of processors, and eagersharing distributed memory, which sends newly written data values over fast network links whenever shared data are written locally. This fast locking method uses queue-based locks and a group root as a lock manager. Write ordering allows lock grants and releases to immediately follow final shared data writes. Most other consistency models need shared writes to be completed globally before lock release. Program execution times are much shorter using group write consistency than weak, release, or entry consistency.<<ETX>>

Operating Systems for the Micronet Network Computer

The Micros operating system executes on a modular multimicroprocessor system. It provides system-wide high-level control as well as local operating systems for individual nodes.

Application of a staggered walk algorithm for generating large-scale morphological neuronal networks

Large-scale models of neuronal structures are needed to explore emergent properties of mammalian brains. Because these models have trillions of synapses, a major problem in their creation is synapse placement. Here we present a novel method for exploiting consistent fiber orientation in a neural tissue to perform a highly efficient modified plane-sweep algorithm, which identifies all regions of 3D overlaps between dendritic and axonal projection fields. The first step in placing synapses in physiological models is neurite-overlap detection, at large scales a computationally intensive task. We have developed an efficient “Staggered Walk” algorithm that can find all 3D overlaps of neurites where trillions of synapses connect billions of neurons.

EC/DSIM: a frontend and simulator for huge parallel systems

This paper presents a new fast way to simulate large networks of computers. The method uses a frontend EC, which accepts a parallel C program and translates it into a program in an intermediate language for parallel system simulations. An event driven simulator for distributed shared memory systems, DSIM, uses the intermediate language to simulate and obtain efficiency results in networks of thousands of processors. In simulations of large parallel systems, enormous memory needs and long execution times are major difficulties. To minimize these problems, the new method analyzes system performance by using extracted execution step information, e.g. the number of shored writes in a code segment, to predict task completion times rather than executing the program step by step. Workstation evaluations of parallel codes running on several thousand processors are feasible using EC/DSIM.<<ETX>>

Analyzing the effects of gap junction blockade on neural synchrony via a motoneuron network computational model

In specific regions of the central nervous system (CNS), gap junctions have been shown to participate in neuronal synchrony. Amongst the CNS regions identified, some populations of brainstem motoneurons are known to be coupled by gap junctions. The application of various gap junction blockers to these motoneuron populations, however, has led to mixed results regarding their synchronous firing behavior, with some studies reporting a decrease in synchrony while others surprisingly find an increase in synchrony. To address this discrepancy, we employ a neuronal network model of Hodgkin-Huxley-style motoneurons connected by gap junctions. Using this model, we implement a series of simulations and rigorously analyze their outcome, including the calculation of a measure of neuronal synchrony. Our simulations demonstrate that under specific conditions, uncoupling of gap junctions is capable of producing either a decrease or an increase in neuronal synchrony. Subsequently, these simulations provide mechanistic insight into these different outcomes.