共查询到20条相似文献,搜索用时 11 毫秒
1.
This paper presents a new approach to programming multiway rendezvous problems in the SR language. The approach uses SR's concurrent invocation statement and rendezvous mechanism to coordinate the interacting processes. This approach is compared with one that suggested an extension to SR's rendezvous mechanism. The two approaches result in differing program structure. The new approach is shown to lead to simpler and cleaner interfaces between the main process and the worker processes, and uses only existing language mechanisms. The results are of importance to both programmers and designers of concurrent program languages. 相似文献
2.
As a result of our experience, the SR distributed programming language has evolved. One change is that resources and processes are now dynamic rather than static. Another change is that operations and processes are now integrated in a novel way: all the mechanisms for process interaction — remote and local procedure call, rendezvous, dynamic process creation, and asynchronous message passing — are expressed in similar ways. This paper explains the rationale for these and other changes. We examine the fundamental issues faced by the designers of any distributed programming language and consider the ways in which these issues could be addressed. Special attention is given to the design objectives of expressiveness, simplicity, and efficiency.
Gregory R. Andrews was born in Olympia, WA, in 1947. He received the B.S. degree in mathematics from Stanford University in 1969 and the Ph.D. degree in computer science from the University of Washington in 1974. From 1974–1979 he was an Assistant Professor of Computer Science at Cornell University. Since 1979 he has been an Associate Professor of Computer Science at the University of Arizona. During 1983–1984, he was a Visiting Associate Professor of Computer Science at the University of Washington. He has also consulted for the U.S. Army Electronics Command and Cray Laboratories. His research interests include concurrent programming languages and distributed operating systems; he is currently co-authoring (with Fred Schneider) a textbook on concurrent programming. Dr. Andrews is a member of the Association for Computing Machinery (ACM). From 1980–1983 he was Secretary-Treasurer of the ACM Special Interest Group on Operating Systems. He has also been on the Board of Editors of Information Processing Letters since 1979.
Ronald A. Olsson was born in Huntington, NY, in 1955. He received B.A. degrees in mathematics and computer science and the M.A. degree in mathematics from the State University of New York, College at Potsdam, in 1977. In 1979, he received the M.S. degree in computer science from Cornell University. He was a Lecturer of Computer Science at the State University of New York, College at Brockport, from 1979 to 1981. Since 1981 he has been a graduate student in computer science at the University of Arizona and will complete his Ph.D. in June 1986. His research interests include programming languages, operating systems, distributed systems, and systems software. Mr. Olsson is a student member of the Association for Computing Machinery.This work is supported by NSF under Grant DCR-8402090, and by the Air Force Office of Scientific Research under Grant AFOSR-84-0072. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes not-withstanding any copyright notices thereon 相似文献
3.
Many concurrent programming languages provide selection statements, which allow a task to select one of several entries to service. The choice as to which entry will be selected, if more than one has pending invocations, is generally defined to be non-deterministic. However, such non-deterministic inter-entry selection can result in undesirable program behavior. This paper examines the problems arising from such behavior and the existing approaches to remedy those problems. It indicates the inherent shortcomings of these approaches and purposes a new, more expressive extension of these approaches that remedies these shortcomings. This paper also considers how the different approaches can be implemented. 相似文献
4.
Arturo Gonzlez-Escribano Arjan J.C. van Gemund Valentín Cardeoso-Payo 《Parallel Computing》2009,35(8-9):455-474
The restricted synchronization structure of so-called structured parallel programming paradigms has an advantageous effect on programmer productivity, cost modeling, and scheduling complexity. However, imposing these restrictions can lead to a loss of parallelism, compared to using a programming approach that does not impose synchronization structure. In this paper we study the potential loss of parallelism when expressing parallel computations into a programming model which limits the computation graph (DAG) to series–parallel topology, which characterizes all well-known structured programming models. We present an analytical model that approximately captures this loss of parallelism in terms of simple parameters that are related to DAG topology and workload distribution. We validate the model using a wide range of synthetic and real-world parallel computations running on shared and distributed-memory machines. Although the loss of parallelism is theoretically unbounded, our measurements show that for all above applications the performance loss due to choosing a series–parallel structured model is invariably limited up to 10%. In all cases, the loss of parallelism is predictable provided the topology and workload variability of the DAG are known. 相似文献
5.
Gregory R. Andrews 《Software》1982,12(8):719-753
SR is a new language for programming software containing many processes that execute in parallel. The language allows an entire software system that controls a potentially large collection of processors to be programmed as an integrated set of software modules. The key language mechanisms are resources, operations and input statements. The language supports separate compilation, type abstraction, and dynamic communication links; it also contains novel treatments of arrays and procedures. This paper gives an overview of the language mechanisms, discusses some of the major design decisions and describes one implementation. 相似文献
6.
SINA is an object-oriented language for distributed and concurrent programming. The primary focus of this paper is on the object-oriented concurrent programming mechanisms of SINA and their implementation. This paper presents the SINA constructs for concurrent programming and inter-object communication, some illustrative examples and a message-based implementation model for SINA that we have used in our current implementation. 相似文献
7.
Per Brinch Hansen 《Software》1987,17(1):29-50
This paper describes a secure programming language called Joyce based on CSP and Pascal. Joyce permits unbounded (recursive) activation of communicating agents. The agents exchange messages through synchronous channels. A channel can transfer messages of different types between two or more agents. A compiler can check message types and ensure that agents use disjoint sets of variables only. The use of Joyce is illustrated by a variety of examples. 相似文献
8.
Richard L. Wexelblat 《Software》1981,11(7):733-740
After seeing many programs written in one language, but with the style and structure of another, I conducted an informal survey to determine whether this phenomenon was widespread and to determine how much a programmer's first programming language might be responsible. This paper discusses my observations, gives informal results of the survey and suggests the need for a more formal study. 相似文献
9.
It was observed that school children in Arab countries find difficulty in learning programming in a language other than their native language. There are only few Arabic programming languages in the literature; most of which are never or partially implemented. In this paper, we present the design of a new Arabic programming language (ARABLAN) which is planned to be implemented for use in teaching programming for school children in Arab countries. 相似文献
10.
Invocation handling mechanism in many concurrent languages have significant limitations that make it difficult or costly to solve common programming situations encountered in program visualization, debugging, and scheduling scenarios. This paper discusses these limitations, introduces new language mechanisms aimed at remedying these limitations, and presents an implementation of the new mechanisms. The examples are given in SR; the new mechanisms and implementation are an extension of SR and its implementation. However, these new mechanisms are applicable to other concurrent languages. They can augment or replace current invocation handling mechanisms. 相似文献
11.
Thomas Plum 《Software》1977,7(2):215-221
Fooling the user' of a programming language by ‘natural’ constructions can cause completely unpredictable reliability defects in software systems. Numerous examples show the extent of the problem. Two methods of overcoming it are presented: simple languages devoid of user-fooling powers, and explication languages to accompany the more powerful languages. 相似文献
12.
Eliminating synchronization faults in air traffic control software via design for verification with concurrency controllers 总被引:1,自引:0,他引:1
Aysu Betin Can Tevfik Bultan Mikael Lindvall Benjamin Lux Stefan Topp 《Automated Software Engineering》2007,14(2):129-178
The increasing level of automation in critical infrastructures requires development of effective ways for finding faults in
safety critical software components. Synchronization in concurrent components is especially prone to errors and, due to difficulty
of exploring all thread interleavings, it is difficult to find synchronization faults. In this paper we present an experimental
study demonstrating the effectiveness of model checking techniques in finding synchronization faults in safety critical software
when they are combined with a design for verification approach. We based our experiments on an automated air traffic control software component called the Tactical Separation
Assisted Flight Environment (TSAFE). We first reengineered TSAFE using the concurrency controller design pattern. The concurrency controller design pattern enables a modular verification strategy by decoupling the behaviors of the concurrency
controllers from the behaviors of the threads that use them using interfaces specified as finite state machines. The behavior
of a concurrency controller is verified with respect to arbitrary numbers of threads using the infinite state model checking
techniques implemented in the Action Language Verifier (ALV). The threads which use the controller classes are checked for
interface violations using the finite state model checking techniques implemented in the Java Path Finder (JPF). We present
techniques for thread isolation which enables us to analyze each thread in the program separately during interface verification.
We conducted two sets of experiments using these verification techniques. First, we created 40 faulty versions of TSAFE using
manual fault seeding. During this exercise we also developed a classification of faults that can be found using the presented
design for verification approach. Next, we generated another 100 faulty versions of TSAFE using randomly seeded faults that
were created automatically based on this fault classification. We used both infinite and finite state verification techniques
for finding the seeded faults. The results of our experiments demonstrate the effectiveness of the presented design for verification
approach in eliminating synchronization faults. 相似文献
13.
Abstract This paper presents a logic programming language of novel conception, called Reflective Prolog, which allows declarative metaknowledge representation and metareasoning. The language is defined by augmenting pure Prolog (Horn clauses) with capabilities of self-reference and logical reflection. Self-reference is designed as a quotation device (a carefully defined naming relation) which allows the construction of metalevel terms that refer to object-level terms and atoms. Logical reflection is designed as an unquotation mechanism (a distinguished truth predicate) which relates names to what is named, thus extending the meaning of domain predicates. The reflection mechanism is embodied in an extended resolution procedure which automatically switches the context between levels. This implicit reflection relieves the programmer from having to explicitly deal with control aspects of the inference process. The declarative semantics of a Reflective Prolog definite program P is provided in terms of the least reflective Herbrand model of P, characterized by means of a suitable mapping defined over the Herbrand interpretations of P. The extended resolution is proved sound and complete with respect to the least reflective Herbrand model. By illustrating Reflective Prolog solutions to an organic set of problems, and by discussing the main differences with respect to other approaches to logic metaprogramming, we show that the proposed language deploys, within its field of action, greater expressive and inferential power than those available till now. The interpreter of the language has been fully implemented. Because of its enhanced power, logic semantics and working interpreter, Reflective Prolog is offered as a contribution toward making the declarative approach of logic programming applicable to the development of increasingly sophisticated knowledge-based systems. 相似文献
14.
Aaron W. Keen Takashi Ishihara Justin T. Maris Tiejun Li Eugene F. Fodor Ronald A. Olsson 《Concurrency and Computation》2003,15(1):27-53
This paper presents a comparison of the cooperative multithreading model with the general concurrent programming model. It focuses on the execution time performance of a range of standard concurrent programming applications. The overall results are mixed. In some cases, programs written in the cooperative multithreading model outperform those written in the general concurrent programming model. The contributions of this paper are twofold. First, it presents a thorough analysis of the performances of applications in the different models, i.e. to explain the criteria that determine when a program in one model will outperform an equivalent program in the other. Second, it examines the tradeoffs in writing programs in the different programming styles. In some cases, better performance comes at the cost of more complicated code. Copyright © 2003 John Wiley & Sons, Ltd. 相似文献
15.
CCNPASCAL is a language derived from Pascal and Concurrent Pascal which has been used in the development of an operating system for a multiprocessor. This paper introduces some of the important features of the language and illustrates them with examples. The language provides mechanisms for interfacing separately compiled modules, for building abstractions of collections of resources and for efficient asynchronous communication. 相似文献
16.
Alexey Lastovetsky Dmitry Arapov Alexey Kalinov Ilya Ledovskih 《Concurrency and Computation》2000,12(13):1317-1343
The paper presents a new parallel language, mpC, designed specially for programming high‐performance computations on heterogeneous networks of computers, as well as its supportive programming environment. The main idea underlying mpC is that an mpC application explicitly defines an abstract network and distributes data, computations and communications over the network. The mpC programming environment uses, at run time, this information as well as information on any real executing network in order to map the application to the real network in such a way that ensures the efficient execution of the application on this real network. Experience of using mpC for solving both regular and irregular real‐life problems on networks of heterogeneous computers is also presented. Copyright © 2000 John Wiley & Sons, Ltd. 相似文献
17.
《Journal of Visual Languages and Computing》2014,25(4):363-375
Objectives: OpenMusic (OM) is a domain-specific visual programming language designed for computer-aided music composition. This language based on Common Lisp allows composers to develop functional processes generating or transforming musical data, and to execute them locally by demand-driven evaluations. As most historical computer-aided composition environments, OM relies on a transformational declarative paradigm, which is hard to conciliate with reactive data-flow (an evaluation scheme more adequate to the development of interactive systems). We propose to link these two evaluation paradigms in the same and consistent visual programming framework.Methods: We establish a denotational semantics of the visual language, which gives account for its demand-driven evaluation mechanism and the incremental construction of programs. We then extend this semantics to enable reactive computations in the functional graphs.Results: The resulting language merges data-driven executions with the existing demand-driven mechanism. A conservative implementation is proposed.Conclusions: We show that the incremental construction of programs and their data-driven and demand-driven evaluations can be smoothly integrated in the visual programming workflow. This integration allows for the propagation of changes in the programs, and the evaluation of graphically designed functional expressions as a response to external events, a first step in bridging the gap between computer-assisted composition environments and real-time musical systems. 相似文献
18.
An increasing number of social computational systems consist of a great amount of autonomous entities and operate in highly dynamic and unpredictable environments. To construct such systems needs to seek high-level abstraction to manage the complexity of the systems and novel mechanism to support their characteristics, i.e., dynamism and flexibility. Agent-oriented programming (AOP) is considered as a potential paradigm for developing such systems by exhibiting a number of characteristics, such as autonomy, flexibility, social ability, etc. However, current researches on AOP mainly focus on the construction of multi-agent system (MAS) with theory and language facilities inspired from artificial intelligence (AI) and distributed AI, seldom considering and integrating the proven principles and practices of programming and software engineering. Moreover, abstractions and mechanism based on AI are inadequate for developing dynamic and flexible MAS in open environment. This paper proposes a novel AOP approach, namely Oragent, for constructing and implementing dynamic and flexible systems. From a software engineering perspective, Oragent integrates organizational concepts and mechanism into AOP language, and support the dynamism and flexibility with explicit primitives. The proposed approach consists of a programming model and a corresponding programming language. This paper presents the syntax and formal operational semantics of Oragent language, and studies a case to demonstrate our approach. 相似文献
19.
The EXODUS database toolkit, and in particular the E persistent programming language, have been used in two substantial database system implementation efforts by the authors, the Ariel database rule system and the Triton nested relation DBMS. An important advantage of using a persistent programming language for database system implementation is that it is easy to implement special-purpose persistent objects used by the DBMS such as catalogs, rule indexes, and nested relational structures. Support for transactions built into a persistent programming language greatly reduces the effort required to implement a database system. A disadvantage observed is that it is not possible to map the type system of the DBMS to the type system of the underlying programming language while still retaining good performance for ad hoc queries. Also, software engineering difficulties arise when a persistent language makes a distinction between database types and main-memory types. 相似文献
20.
Justin T. Maris Aaron W. Keen Takashi Ishihara Ronald A. Olsson 《Concurrency and Computation》2004,16(4):345-369
Two models of thread execution are the general concurrent programming execution model (CP) and the cooperative multithreading execution model (CM). CP provides nondeterministic thread execution where context switches occur arbitrarily. CM provides threads that execute one at a time until they explicitly choose to yield the processor. This paper focuses on a classic application to reveal the advantages and disadvantages of load balancing during thread execution under CP and CM styles; results from a second classic application were similar. These applications are programmed in two different languages (SR and Dynamic C) on different hardware (standard PCs and embedded system controllers). An SR‐like run‐time system, DesCaRTeS, was developed to provide interprocess communication for the Dynamic C implementations. This paper compares load balancing and non‐load balancing implementations; it also compares CP and CM style implementations. The results show that in cases of very high or very low workloads, load balancing slightly hindered performance; and in cases of moderate workload, both SR and Dynamic C implementations of load balancing generally performed well. Further, for these applications, CM style programs outperform CP style programs in some cases, but the opposite occurs in some other cases. This paper also discusses qualitative tradeoffs between CM style programming and CP style programming for these applications. Copyright © 2004 John Wiley & Sons, Ltd. 相似文献