History of the Actor model

In computer science , the Actor model , first published in 1973, is a mathematical model of concurrent computation .

Event orderings versus global state

A fundamental challenge in defining the Actor model is that it did not provide for global states so that it was computational step in the global state of the world.

In 1963 in the field of artificial intelligence , John McCarthy introduced situational variables in the Situational Calculus. In McCarthy and Hayes 1969, a situation is defined as “the complete state of the universe at an instant of time.” In this respect, the situations of McCarthy are not suitable for use in the Actor model since it has no global states.

From the definition of an actor, it can be seen that many events take place: local decisions, creating Actors, sending messages, receiving messages, and designating how to respond to the next message received. Partial orderings on such events have been axiomatized in the Actor model and their relationship to physics explored (see Actor model theory ).

Relationship to physics

According to Hewitt (2006), the Actor model is based on physics in contrast with other models of computation that have been based on mathematical logic, set theory, algebra, and so on. Physics influenced the Actor model in many ways, specifically quantum physics and relativistic physics . One issue is what can be observed about Actor systems. The question does not have an obvious answer because it poses both theoretical and observational challenges similar to those that had arisen in constructing the foundations of quantum physics. In concrete terms for Actor systems, the following is a feature of the present invention ( in French: Indeterminacy en concurrent computation). Attempting to do so and perhaps pushing the indeterminacy elsewhere. eg , see metastability in electronics . Instead of observing the insides of arbitration processes of Actor computations, we await the outcomes.

Models prior to the Actor model

The Actor model builds on previous models of computation.

Lambda calculus

The lambda calculus of Alonzo Church can be viewed as the message passing programming language (see Hewitt, Bishop, and Steiger 1973, Abelson and Sussman 1985 ). For example, the lambda expression below implements a tree data structure when supplied with parameters for a leftSubTree and rightSubTree . When such a tree is given a parameter message "getLeft" , it returns leftSubTree and likewise when given the message "getRight" it returns rightSubTree .

λ (leftSubTree, rightSubTree)
 λ (message) if (message == "getLeft") then leftSubTree
 else if (message == "getRight") then rightSubTree

However, the semantics of the lambda calculus have been expressed using variable substitution in which the values ​​of parameters have been replaced by an invoked lambda expression. The substitution model is unsuitable for concurrency because it does not allow the possibility of sharing of changing resources. Inspired by the lambda calculus, the interpreter for the programming language Lisp made use of a data structure called Expired year environment so que le values of parameters Did not-have to be Substituted into the body of an Invoked lambda expression. This allowed for sharing of the effects of a common data structure did not provide for concurrency.

Simula

Simula 67 pioneered using message passing for computation, motivated by discrete event simulation applications. These applications had become large and unmodular in previous simulation languages. At each time step, a large central program would have to go through and update the state of each simulation object that is depending on the state of whichever simulation objects it interacted with on that step. Kristen Nygaard and Ole-Johan Dahl Developed the idea (first year Described in IFIP workshop in 1967) of HAVING methods were Each object That Would update icts own local state is based messages from other objects. In addition they introduced a class structure for objects withinheritance . Their innovations have improved the modularity of programs.

However, Simula used coroutine control structure instead of true concurrency.

Smalltalk

Alan Kay was influenced by message passing in the pattern-directed invocation of Planner in developing Smalltalk -71. Hewitt Was intrigued by Smalltalk-71 goal Was put off by the complexity of communication That included invocations with Many fields Including overall , sender , receiver , reply-style , status , reply , operator selector , etc.

In 1972 Kay visited MIT and discussed some of his ideas for Smalltalk-72 building on the Logo of Seymour Papert and the “little person” model of computation used for teaching children to program. However, the message passing of Smalltalk-72 was quite complex. Code in the language of the interpreter as simply a stream of tokens. As Dan Ingalls later described it:

The first (token) encountered (in a program) was looked up in the dynamic context, to determine the receiver of the subsequent message. The name lookup started with the class dictionary of the current activation. Failing there, it moved to the sender of that activation and so on up the sender chain. When it is finally found for the token, its value becomes the receiver of a new message, and the interpreter is activated for the object.

Thus the message-passing model in Smalltalk-72 was closely linked to a particular machine model and programming-language that did not lend itself to concurrency. Also, the system was bootstrapped on itself, the language constructs were not formally defined as responding to Eval messages (see discussion below). This is a new computational model based on message passing should be simpler than Smalltalk-72.

Subsequent Versions of the Smalltalk language, followed by the path of the virtual methods of Simula in the message-passing structure of programs. However Smalltalk-72 made primitives such as integers, floating point numbers, etc. into objects . The authors of Simula Java at first using the expedient of having both primitive and object versions of integers, floating point numbers, etc. The C # programming language (and later versions of Java, starting with Java 1.5) adopted the less elegant solution of using boxing and unboxing, A variant of qui HAD-been used Earlier In Some Lisp implementations.

The Smalltalk system went to become very influential, innovating in bitmap displays, personal computing, the class browser interface, and many other ways. Kay’s The Early History of Smalltalk . [1] Meanwhile, the Actor’s efforts at MIT have been focused on developing the science and engineering of higher level concurrency. (See the paper by Jean-Pierre Briot, editor-in-chief of Smalltalk.)

Petri nets

Prior to the development of the Actor model, Petri nets were widely used to model nondeterministic computation. However, they were widely acknowledged to have an important limitation: Therefore, they were not able to edit their modularity. Hewitt pointed out another difficulty with Petri nets: simultaneous action. Ie , the atomic step of computation in Petri nets is a transition in which tokens simultaneouslyDisappearing from the world of places of transition The physical basis of a primitive with this kind of simultaneity seemed questionable to him. Despite these apparent difficulties, Petri nets continues to be a popular approach to modeling concurrency, and is still the subject of active research.

Threads, locks, and buffers (channels)

Prior to the Actor model, concurrency was defined in low-level machine terms of threads , locks and buffers ( channels ). It certainly is the case that implementations of the Actor model typically make use of these hardware capabilities. However, there is no reason that the model could not be implemented directly in hardware without exposing any hardware threads and locks. Also, there is no necessary relationship between the Actors, threads, and locks that might be involved in a computation. Implementations of the Actor are in the process of being used in the United States and in the United States.

Abstracting away implementation details

An important challenge in defining the Actor model.

For example, consider the following question: “Does each actor have a tail in which its communications are stored by the Actor to be processed?” Carl Hewitt argued against these issues as an integral part of the Actor model. One consideration Was That Such tails Themselves Could be modeled as Actors That received messages to enqueue and dequeue the communications. Another consideration was that some Actors would not use such queues in their actual implementation. Eg, an Actor could have a network of arbiters instead. Of course, there is a mathematical abstraction which is the sequenceof communications that have been received by an Actor. But this sequence was only successful as the Actor operated. In fact the ordering of this sequence can be indeterminate (see Indeterminacy in concurrent computation ).

Another example of abstracting away implementation is the question of interpretation : “Should the interpretation be an integral part of the Actor model?” The idea of interpretation Is That Would Be an Actor defined by how ict program processed script eval messages. (In this way Actors would be defined in a manner analogous to Lisp which was “defined” by a meta-circular interpreter procedure named eval written in Lisp.) One consideration was that to process the evalmessages, the program script of an Actor would have a program script (which in turn would have …)! Another consideration was that some Actors would not use interpretation in their actual interpretation. Eg, an Actor might be implemented in hardware instead. Of course there is nothing wrong with interpretation per se . Also implementing interpreters using eval messages is more modular and extensible than the monolithic interpreter approach of Lisp.

Operational model

Nevertheless, progress developing the model was steady. In 1975, Irene Greif published the first operational model in her dissertation.

Scheme

Gerald Sussman and Guy Steele then took an interest in the Actors and published a paper on their Scheme interpreter in which they concluded that the actors and the lambda expressions were identical in implementation. According to Hewitt, the lambda calculus is capable of expressing some kinds of parallelism but, in general, not the concurrency expressed in the Actor model. On the other hand, the Actor model is capable of expressing all of the parallels in the lambda calculus.

Laws for Actors

Two years after Greif published her operational model, Carl Hewitt and Henry Baker published the Laws for Actors.

Proof of continuity of computable functions

Using the Laws of the Actor Model, Hewitt and Baker proved that any actor was a function of continuous searching by Dana Scott (see denotational semantics ).

Specifications and proofs

Aki Yonezawa published his specification and verification techniques for Actors. Russ Atkinson and Carl Hewitt published a paper on standardization and proofing techniques for serialization providing an efficient solution for encapsulating shared resources for concurrency control .

Mathematical characterization using domain theory

Finally eight Years After the first Actor publication, Will Clinger (building on the work of Irene Greif 1975 Gordon Plotkin 1976 Michael Smyth 1978 Henry Baker 1978 Francez, Hoare , Lehmann, and of Roever 1979 and Milne and Milnor 1979) published the first mathematical Satisfactory denotational model Incorporating unbounded nondeterminism using domain theory in His dissertation in 1981 (see Clinger’s model ). Subsequently, Hewitt [2006] augmented the diagrams to a technically simplified denotational modelthat is easier to understand. See History of denotational semantics .

See also

  • Actor model and process calculi history
  • History of denotational semantics
  • Actor model middle history
  • Actor model later history

References

  1. Jump up^ Kay, Alan (March 1993). “The Early History of Smalltalk” (PDF) . ACM SIGPLAN . 28 (3): 69-75. doi : 10.1145 / 155360.155364 . Archived from the original (PDF) on 2012-02-05.
  • Carl Hewitt; Peter Bishop; Richard Steiger (1973). “A Universal Modular Actor Formalism for Artificial Intelligence” . IJCAI: 235-245.
  • McCarthy, John (1963). “Situations, actions and causal laws”. Technical Report Memo . Stanford University Artificial Intelligence Laboratory (2).
  • McCarthy, John; Hayes, Patrick (1969). “Some Philosophical Problems from the Standpoint of Artificial Intelligence” . Machine Intelligence . Edunburgh University Press (4).
  • Heisenberg, Werner (1971). Physics and Beyond: Encounters and Conversations . Translated by AJ Pomerans. New York: Harper & Row. pp. 63-64. ISBN  978-0061316227 .
  • Hewitt, Carl; Bishop, Peter; Greif, Irene; Smith, Brian; Matson, Todd; Steiger, Richard (January 1974). “Actor Induction and Meta-evaluation”. Conference Record of ACM Symposium on Principles of Programming Languages : 153. doi : 10.1145 / 512927.512942 .
  • Hewitt, Carl (April 1974). Behavioral Semantics of Nonrecursive Control Structure . Proceedings of Seminar on Programming : 385-407.
  • Greif, Irene; Hewitt, Carl (January 1975). “Actor Semantics of PLANNER-73”. Conference Record of ACM Symposium on Principles of Programming Languages : 67. doi : 10.1145 / 512976.512984 .
  • Hewitt, Carl (September 1975). “How to Use What You Know”. 4th International Joint Conference on Artificial Intelligence . 1 : 189-198.
  • Greif, Irene (1975). Semantics of Communicating Parallel Professes (Ph.D.). MIT EECS .
  • Baker, Henry; Hewitt, Carl (August 1977). “The Incremental Garbage Collection of Processes” . Proceedings of the Symposium on Artificial Intelligence Programming Languages .
  • Hewitt, Carl; Baker, Henry (August 1977). “Laws for Communicating Parallel Processes” . International Federation for Information Processing .
  • Yonezawa, Aki (1977). Specification and Verification Techniques for Parallel Programs Based on Message Passing Semantics (Ph.D. MIT EECS .
  • Biship, Peter (1977). Very Large Address Modularly Extensible Space Computer Systems (Ph.D.). MIT EECS .
  • Hewitt, Carl (June 1977). “Viewing Control Structures as Patterns of Passing Messages” . Journal of Artificial Intelligence .
  • Baker, Henry (1978). Actor Systems for Real-Time Computation (PhD). MIT EECS .
  • Hewitt, Carl; Atkinson, Russ (January 1979). “Specification and Proof Techniques for Serializers” . IEEE Journal on Software Engineering : 10. doi : 10.1109 / TSE.1979.234149 .
  • Kahn, Ken (1979). A Computational Theory of Animation (Ph.D.). MIT EECS .
  • Hewitt, Carl; Attardi, Beppe; Lieberman, Henry (October 1979). “Delegation in Message Passing”. Proceedings of First International Conference on Distributed Systems . Huntsville, AL.
  • Atkinson, Russ (1980). Automatic Verification of Serializers (Ph.D.). MIT .
  • Kornfeld, Bill; Hewitt, Carl (January 1981). “The Scientific Community Metaphor”. IEEE Transactions on Systems, Man, and Cybernetics . 11 : 24. doi : 10.1109 / TSMC.1981.4308575 .
  • Lieberman, Henry (May 1981). “Thinking About Lots of Things at Once Without Getting Confused: Parallelism in Act 1” . MIT AI memo (626).
  • Lieberman, Henry (June 1981). “A Preview of Act 1” . MIT AI memo (625).
  • Barber, Gerry (1981). Reasoning about Change in Knowledgeable Office Systems (PhD). MIT EECS .
  • Kornfeld, Bill (1981). Parallelism in Problem Solving (Ph.D.). MIT EECS .
  • Clinger, Will (1981). Foundations of Actor Semantics (Ph.D.). MIT Mathematics .
  • Theriault, Daniel (April 1982). “Primer for the Act-1 Language” . MIT AI memo (672).
  • Lieberman, Henry; Hewitt, Carl (June 1983). “A Real Time Garbage Collector Based on the Lifetimes of Objects”. Communications of the ACM . 26 (6): 419. doi : 10.1145 / 358141.358147 .
  • Theriault, Daniel (June 1983). “Issues in the Design and Implementation of Act 2” . MIT AI technical report (728).
  • Lieberman, Henry (August 1983). “An Object-Oriented Simulator for the Apiary” (PDF) . Conference of the American Association for Artificial Intelligence . Washington, DC
  • Hewitt, Carl; de Jong, Peter (August 1983). “Analyzing the Roles of Descriptions and Actions in Open Systems” . Proceedings of the National Conference on Artificial Intelligence .
  • Jammer, M. (1985). “The EPR Problem in Its Historical Development”. In P. Lahti, P. Mittelstaedt. Symposium on the Foundations of Modern Physics: 50 years of the Einstein-Podolsky-Rosen Gedanken experiment . Singapore: World Scientific. pp. 129-149.
  • Fine, A. (1986). The Shaky Game: Einstein Realism and the Quantum Theory . Chicago: University of Chicago Press. ISBN  978-0226249476 .
  • Hewitt, Carl; Lieberman, Henry (November 1983). “Design Issues in Parallel Architecture for Artificial Intelligence” . MIT AI memo (750).
  • Fuchs, Christopher (2002). Quantum mechanics as quantum information (and only a little more). In A. Khrenikov. Quantum Theory: Reconstruction of Foundations . Växjo: Växjo University Press.
  • Hewitt, Carl (April 27, 2006). “What is the Commitment? Physical, Organizational, and Social” (PDF) . COIN @ AAMAS .

Leave a Reply

Your email address will not be published. Required fields are marked *

Copyright computerforum.eu 2018
Shale theme by Siteturner