Abstract
NERECO (NEtwork REmote COmmunications) is a programming framework designed to bridge the gap between sequential programming and distributed system complexity. By extending familiar languages like C, Pascal, and CHILL with high-level concurrent constructs based on Communicating Sequential Processes (CSP), NERECO provides abstractions for asynchronous communication, explicit fault handling, and network transparency. This paper details the architecture of NERECO—comprising a rational preprocessor, a static consistency checker, and a runtime virtual machine—demonstrating a portable and robust approach to building distributed applications without the overhead of specialized concurrent languages or the fragility of low-level socket programming.
1. Introduction
In the late 1980s and early 1990s, the development of distributed software was characterized by a stark dichotomy. Developers were forced to choose between complex, specialized concurrent languages like Ada or Occam, which often imposed rigid programming paradigms, or low-level operating system primitives such as UNIX sockets. The former required a steep learning curve and often lacked portability, while the latter were notoriously error-prone, difficult to scale, and forced developers to manage manual synchronization and network-specific logic.
NERECO was developed to address this gap. It provides a high-level abstraction layer that treats processes as encapsulated "abstract data types" communicating via messages, while remaining compatible with the sequential languages already established in the engineering community. The system specifically targets three core challenges in distributed computing: nondeterminism, network transparency, and fault recovery.
2. The NERECO System Architecture
The NERECO framework is built upon three primary pillars: a language model, a suite of static development tools, and a runtime support layer.
2.1 The Language Model
While NERECO draws its theoretical foundation from Hoare’s Communicating Sequential Processes (CSP), it introduces several "real-world" extensions necessary for distributed environments:
- Asynchronous Channels: Unlike the strictly synchronous nature of standard CSP, NERECO supports buffered communication. This allows senders to proceed without waiting for a receiver to be ready, increasing system throughput.
- Asymmetric Communication: To support modern networking patterns, NERECO enables one-to-many communication, such as broadcast and multicast, which are highly efficient on local area networks like Ethernet.
- Dynamic Channels: The system allows process connections to be reconfigured at runtime using
processnamevariables, providing the flexibility needed for evolving distributed topologies. - Fault-Tolerance Clauses: Recognizing that failure is inevitable in distributed systems, NERECO introduces specific statements—
onfail,onterm, andonprot—to trigger forward recovery actions if a partner process crashes or a communication link fails.
2.2 Static Tools
NERECO employs a "rational preprocessor" approach to maintain language independence. The Precompiler translates concurrent constructs into standard sequential code interspersed with calls to a specialized runtime library.
To ensure system integrity, a Consistency Checker performs static analysis across process boundaries. This tool ensures that communication interfaces match—for example, verifying that if Process A is programmed to send an integer, Process B is configured to receive one. Finally, a Configurator tool maps logical processes to physical network nodes. This separation of logic from topology allows developers to change the hardware deployment without modifying the source code.
2.3 Runtime Support
The runtime environment acts as a virtual machine layer implemented on top of UNIX 4.2BSD. Utilizing standard sockets for message routing and process management, this layer abstracts the underlying operating system complexities from the application logic.
3. Key Insights and Design Philosophy
The primary innovation of NERECO lies in its "glue" approach. Rather than inventing a new language, it provides the concurrent infrastructure to link existing sequential modules. This preserves programmer productivity while offering a robust framework for distribution.
By treating channels as typed logic objects, the system catches interface mismatches at compile-time, preventing the mysterious runtime crashes common in socket-based programming. Furthermore, the system achieves location transparency; because the Configurator handles process-to-host mapping, a program can be moved from a single workstation to a large network without altering the application logic. Finally, the inclusion of forward recovery clauses directly within I/O commands acknowledges that distributed systems must be built to handle partial failures gracefully.
4. Implementation and Results
The NERECO system was fully implemented in C on a network of Sun workstations. To evaluate its efficacy, the authors implemented a functional example of a distributed resource allocator. The results demonstrated that NERECO could successfully manage complex distributed patterns, such as partitioned or replicated resource management, using a relatively small and general-purpose set of constructs. The architecture proved highly portable, as language-dependent elements were isolated in the precompiler and OS-dependent elements were confined to the runtime support layer.
5. Limitations and Future Work
Despite its successes, NERECO has certain architectural limitations. To avoid the overhead associated with "heavyweight" UNIX processes, the system does not support process nesting. Additionally, while the configurator includes basic load-balancing capabilities, these are treated as secondary features rather than automated runtime optimizations. Finally, while the system performed well on local area networks, the scalability of its central logging (NETLOG) and Network Server (NS) processes in wide-area network (WAN) environments remains a subject for further investigation.
Summary updated