A VAXcluster is a highly available and extensible configuration of VAX computers that operate as a single system. To achieve performance in a multicomputer environment, a new communications architecture, communications hardware, and distributed software were jointly designed. The software is a distributed version of the VAX/VMS operating system that uses a distributed lock manager to synchronize access to shared resources. The communications hardware includes a 70 megabit per second message-oriented interconnect and an interconnect port that performs communications tasks traditionally handled by software. Performance measurements show this structure to be highly efficient, for example, capable of sending and receiving 3000 messages per second on a VAX-11/780.

/pdf/vaxcluster-a-closely-coupled-distributed-system-4kestcl07x.pdf

VAXcluster: a closely-coupled distributed system

Active networks accelerate network evolution by permitting the network infrastructure to be programmable, on a per-user, per-packet, or other basis. This programmability must be balanced against the safety and security needs inherent in shared resources.This paper describes the design, implementation, and performance of a new type of network element, an Active Bridge. The active bridge can be reprogrammed "on the fly", with loadable modules called switchlets. To demonstrate the use of the active property, we incrementally extend what is initially a programmable buffered repeater with switchlets into a self-learning bridge, and then a bridge supporting spanning tree algorithms. To demonstrate the agility that active networking gives, we show how it is possible to upgrade a network from an "old" protocol to a "new" protocol on-the-fly. Moreover, we are able to take advantage of information unavailable to the implementors of either protocol to validate the new protocol and fall back to the old protocol if an error is detected. This shows that the Active Bridge can protect itself from some algorithmic failures in loadable modules.Our approach to safety and security favors static checking and prevention over dynamic checks when possible. We rely on strong type checking in the Caml language for the loadable module infrastructure, and achieve respectable performance. The prototype implementation on a Pentium-based HP Netserver LS running Linux with 100 Mbps Ethernet LANS achieves ttcp throughput of 16 Mbps between two PCs running Linux, compared with 76 Mbps unbridged. Measured frame rates are in the neighborhood of 1800 frames per second.

Active bridging

Fault-tolerance is the architectural attribute of a digital system that keeps the logic machine doing its specified tasks when its host, the physical system, suffers various kinds of failures of its components. A more general concept of fault-tolerance also includes human mistakes committed during software and hardware implementation and during man/machine interaction among the causes of faults that are to be tolerated by the logic machine. This paper discusses the concept of faulttolerance, the reasons for its inclusion in digital system architecture, and the methods of its implementation. A chronological view of the evolution of fault-tolerant systems and an outline of some goals for its further development conclude the presentation.

Fault-tolerance: The survival attribute of digital systems

ion methodology does not offer any aids for actually structuring data and tailoring parallel operations to "match" the data's structure. Hence it not as supportive of the finer grain parallelism found in some other types of architectures, such as in vector processors. We turn now to the subject of program control structures to determine what characterizes parallel programming. Over the past decade several different nonsequential control structures have come into use. For the most part they arose independently of the need for them in distributed computers. It is our contention that they arose because programmers needed better tools to cope with the increased complexity observed in larger and larger programming tasks. The control structures that we review in the following paragraphs are all characterized by the fact that the programmer need only focus on a small program, not on overall control of the computation. Our first example is the message-based organization. Three quite different systems that explore the use of message-based control are Smalltalk, Actors, and StarOS [GOLD76, INGA77, HEWI73]. In all three systems, computation is performed by multiple homogeneous processes that execute independently and interact via messages. The grain size of a typical process differs from system to system. Much has been written about message-based systems, so we will not explore them further, except to note that a message-based organization seems quite compatible with parallel execution. In fact, the message-based control was chosen for StarOS because it appears to be particularly amenable to multiprocessors. We shall discuss in more detail a lesser known nonsequential control structure that we call the chore structure. Assume that all code is broken into small units. For convenience we refer to both the process that executes the unit of code and the code itself as a "chore." A key property is that once a Using Multiprocessor Systems • 135 chore begins execution, it runs to completion. Chores are small. They have relatively little input, and they address very few different objects. They do not block, and they are noninterruptible. As part of its output one chore might request execution of some modest set of additional chores. We can cite two examples of the use of chores. PLURIBUS software is constructed as a set of "strips" of code, each of limited execution duration. Each strip is a chore. Associated with each strip is an integer name and a statically assigned priority. In order to schedule a strip to be executed, its integer name is placed in the hardware-maintained PID. Recall that the PID maintains its queue of strip names in priority order. Before it becomes idle, a processor attempts to remove a name from the PID. If successful, the processor executes the associated strip. We will not discuss this example in further detail because it is well documented in the literature. Another example system that is implemented according to the chore paradigm is the BCC-500 [LAMP69]. The computer consists of five microcoded processors sharing primary memory. Each processor is dedicated to providing a specific function. Two of the five processors only execute user processes. The remaining three processors are dedicated to memory hierarchy management, terminal I/O management, and processor scheduling, respectively. We focus on the memory management processor, which controls swapping between primary memory and a fixed-head Burroughs drum [BERK69]. It is organized using the chore paradigm to assure that real-time constraints imposed by the drum are met. The processor must place commands in drum controller registers just before a sector of interest comes under the heads. Because the high-priority chore that writes the controller registers may need to do so every 1⁄4 millisecond, no other chore can execute longer than 1⁄4 millisecond. The memory manager has a set of request queues. Each queue holds only a certain type of chore request. Sample chores include (1) preparing a drum command requesting transmission of a 6-kilobyte page of data between the drum and primary memory, (2) noting completion of a drum Computing Surveys, Vol. 12, No. 2, June 1980 136 • Anita K. Jones and Peter Schwarz sector transmission and arranging for any subsequent action--e.g., retransmission in case the transmission failed, (3) accepting the identity of a process image that the scheduler wants swapped in, and (4) placing requests to swap out each of the dirty pages in a process' working set into the proper sector queues. We have illustrated the control organization for memory management. For the most part it involves a single processor. However the control mechanism is used more generally. The scheduler that assigns processors to execute user processes communicates with the memory manager by queuing a chore request. Similarly, the memory manager replies by queuing a chore request in the chore queues serviced by the scheduler. The key attribute is that the same control and communication structures are used inside and outside a single task or a single processor. Contrasting the PLURIBUS and BCC500 implementation of chores, we find that PLURIBUS employs a single, possibly replicated, hardware queue for scheduling chores. The BCC-500 uses multiple queues, each with a statically assigned priority. In both systems all chores effectively have a static priority. The BCC-500 request includes some parameter information; the PLURIBUS chore requests do not. Both use chore requests to communicate the need to perform another chore, regardless of whether the chore will or will not be performed by the processor that originated the request. This facilitates expansion of the system or a rearrangement of chores and processor affiliation (if any). The last nonsequential control structure that we wish to discuss is that of production systems, now routinely used in artificial intelligence systems [NEWE73, DAVI77, SHOR76]. Productions are expressions of the form (antecedent, consequent). Whenever the Boolean antecedent evaluates to "true," the consequent may be performed. Productions may be very large or very small, as measured by the amount of state or computation involved. In contrast to chores, production consequents may or may not include code which might block. Production systems incorporate four scheduling strategies: (1) to control selection of antecedents to be evaluated next, (2) to order (if appropriate) the execution of selected antecedents, (3) to select the subset of runnable consequents to be executed, and (4) to order (if appropriate) the execution of the selected consequents. By their nature production systems are also compatible with parallel execution. Note the similarity of productions and chores. We conclude that parallel programming does not give rise to the need for substantially new and different paradigms or methodologies. The art of programming is evolving. As we have illustrated, some of the newer methods and methodologies that have evolved to cope with the rising complexity of software are nonsequential. Hence they are well suited for implementation on a multiprocessor. As mentioned earlier, there is a myth that parallel software is more complex than sequential software. Statements of the myth rarely distinguish between anything other than parallelism or the lack thereof. The issue is not simple to deal with. When we say that something is complex, we mean that it is difficult for people to understand. A paraphrase of the myth might be "Parallel systems of programs are difficult to design, to build, and to understand." We believe this myth to be false. In previous paragraphs we cited examples of control structures having implicit parallelism. Production systems are perhaps the best example because their history is by and large divorced from that of multiprocessing. We can present some additional evidence, which we interpret to mean that parallel software is not more difficult to build than sequential software. Consider the HYDRA system. It is roughly 230 kilobytes of code. Productivity measurements of the production of the system show that programmers produced an average of 26 lines of debugged Bliss code per day throughout the system construction. In addition, the number of lines of code in the system linearly increased over time. According to W. A. Wulf, as the system grew in size programmers continued at the same productivity level. Productivity was also high in the construction of the HYDRA File System, a userlevel program. The implementors, Guy Alines and George Robertson, were able to produce over 30 lines of debugged Bliss code per day. We interpret these statistics Computing Surveys, Vol 12, No. 2, June 1980

Experience Using Multiprocessor Systems—A Status Report

A task communicator for each computer in a multiple computer system is disclosed. The task communicator provides communication of data values between cooperating tasks executed by different computers. The task communicator comprises a data values table (804) storing the current data values required for the execution of each task assigned to its computer. A store data value module (802) which stores the data values received from the other computers in the data values table. A task dispatcher (806) which copies the data values required for the execution of a selected task into a task input table (810). A release task module (814), which releases for execution the identified task and data values stored in the task input table. A task output table (812) storing the values of the data resulting from the execution of each task by its own computer. A task results message sender (818) which sends to all of the computers in the system messages containing the new data values stored in the task output table by the executed task.

Task communicator for multiple computer system

The authors describe the Pluribus multiprocessor system, outline several techniques used to achieve fault-tolerance, describe their field experience to date, and mention some potential applications. The Pluribus system places the major responsibility for recovery from failures on the software. Failing hardware modules are removed from the system, spare modules are substituted where available, and appropriate initialization is performed. In applications where the goal is maximum availability rather than totally fault-free operation, this approach represents a considerable savings in complexity and cost over traditional implementations. The software-based reliability approach has been extended to provide enror-handling and recovery mechanisms for the system software structures as well. A number of Pluribus systems have been built and are currently in operation. Experience with these systems has given us confidence in their performance and maintainability, and leads us to suggest other applications that might benefit from this approach.

Pluribus&#8212;An operational fault-tolerant multiprocessor

Handle everyday research tasks with reliable, citation-backed results

Your personal Research Agent to handle research tasks with citation-backed results

Popular Tasks used by Researchers

How can I help with your research?

Meet SciSpace

Get more enhanced response by uploading the PDFs you want me to reference.

No relevant PDFs in your library

SciSpace is the AI research assistant for academics. Run systematic literature reviews on 280M+ papers, and write papers with cited sources. Trusted by 1M+ students, PhDs & researchers.

SciSpace | AI for Research

Analyze PDFs

Code & Manuscripts

Funding & Grants

Literature & Patents

Medical & Clinical Data

Systematic Review

Visualize & Present

Web & Data

Build a Google Scholar-like website for your research.

Build a website

Create charts and images for your research

Create a Chart

Write a paper for submission to a journal

Draft a manuscript

Patent Search

Design eye-catching scientific posters in minutes.

Scientific Poster Generation

Systematic Literature Review

One task is running at the moment. Your messages will be shown right after.

Drag and drop or click here to browse

Loved by <highlight>1 million+</highlight> researchers

Extract a list of specific topics and their sources from unstructured text

Topics

Compare and analyze relevant papers that matches with your search

Papers

Get insights from PDFs and bookmarked papers from your library

My library

Recent searches

Try searching for:

Catch AI-generated content in scholarly and non-scholarly content

{ai} Detector

Ai Writer

Get PDF Summaries, highlighted text explanations 

Chat with PDF

Effortlessly create in-text citations and bibliographies in APA and 2,500 other formats

Citation generator

Get explanations, summaries, and answers on academic papers

Ease up your research workflow with {scispace}'s cohort of exciting AI tools

Elevate your academic writing skills and convey your ideas the way you want

Paraphraser

Explore our range of reading and writing tools

Your file is being prepared and should be ready in a few minutes. If it's a large file, it might take a bit longer. You can close this window, and we'll email you the file when it's done.

You have reached a maximum limit of <strong>{limit}</strong> columns in the table. Remove at least <strong>1</strong> column to add or create another one.

E.W. Wolf

Author Tools

Chat about Author

Papers

Pluribus—An operational fault-tolerant multiprocessor

E.W. Wolf

Author Tools

Chat about Author

Papers

Pluribus&#8212;An operational fault-tolerant multiprocessor

Pluribus—An operational fault-tolerant multiprocessor