Actors interact by asynchronous message passing. A key semantic property of actors is that they do not share state. This facilitates data-race freedom, fault isolation and location transparency. On the other hand, strict avoidance of sharing can lead to inefficiency. We propose the sharing actor programming model that extends the actor programming model with single-writer multiple-reader sharing of data. We define the sharing actor theory and prove its semantic equivalence to the pure actor theory. We realize the sharing actor theory with an efficient implementation. The implementation benefits from sharing data but keeps it transparent to actors. To increase the confidence that the implementation complies with the semantics, we have built a checking tool based on deterministic replay of actor programs.
{"title":"Semantics-preserving sharing actors","authors":"M. Lesani, A. Lain","doi":"10.1145/2541329.2541332","DOIUrl":"https://doi.org/10.1145/2541329.2541332","url":null,"abstract":"Actors interact by asynchronous message passing. A key semantic property of actors is that they do not share state. This facilitates data-race freedom, fault isolation and location transparency. On the other hand, strict avoidance of sharing can lead to inefficiency. We propose the sharing actor programming model that extends the actor programming model with single-writer multiple-reader sharing of data. We define the sharing actor theory and prove its semantic equivalence to the pure actor theory. We realize the sharing actor theory with an efficient implementation. The implementation benefits from sharing data but keeps it transparent to actors. To increase the confidence that the implementation complies with the semantics, we have built a checking tool based on deterministic replay of actor programs.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"14 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115448500","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The software for today's personal computing environments has become so complex that no single person can understand an entire system. Our group's early experiences with personal computing led us to understand that the essential model of personal computing can be expressed much more compactly. Our group engaged in a project (called the STEPS project) to materialize that vision over the last six years. Several interesting results came out of the STEPS project. There are various meta-language implementations. A new stream-processing language called Nile was invented. The syntax of Nile allows a fully-featured vector graphics engine called Gezira to be written in a clean, mathematical manner in less than 500 lines of code. We also wrote a dynamic, yet declarative, graphical user interface framework in which we built a universal document editor. From the experience with the STEPS project, we are exploring the next steps; one of the directions is to incorporate the idea of using multiple constraint solvers to build a system. Solvers can help stronger "negotiation" between objects and languages, and help the system to be written in a more declarative manner. Another direction is to take the idea of loose-coupling to the next level; objects should not know about other objects directly but should always negotiate and "find" other objects. As the basic concept for this next stage, we are using the "Internet all the way down" analogy. The Internet has proven itself to be a great engineering feat: it scaled from just four nodes to billions of nodes without ever needing a full shutdown for maintenance. It is also likely that we can take out a random 10% of the Internet's nodes and it will still keep running. By building a personal computing environment that consists of such nodes, or objects, perhaps we can make it never need to be restarted. Interestingly, J. C. R. Licklider already foresaw the need for program components to discover each other on a huge network of computers. From that viewpoint, what we are trying to do is to carry the vision forward.
当今个人计算环境的软件已经变得如此复杂，以至于没有一个人能够理解整个系统。我们小组在个人电脑方面的早期经验使我们认识到，个人电脑的基本模型可以用更简洁的方式表达。在过去的六年里，我们的团队参与了一个项目(称为STEPS项目)来实现这一愿景。STEPS项目产生了几个有趣的结果。有各种各样的元语言实现。一种叫做Nile的新的流处理语言被发明了。Nile的语法允许一个功能齐全的矢量图形引擎Gezira用不到500行代码以简洁、数学的方式编写。我们还编写了一个动态的、声明式的图形用户界面框架，并在其中构建了一个通用文档编辑器。根据STEPS项目的经验，我们正在探索下一步;其中一个方向是结合使用多个约束求解器来构建系统的思想。求解器可以帮助对象和语言之间进行更强的“协商”，并帮助系统以更具声明性的方式编写。另一个方向是将松耦合的思想提升到下一个层次;对象不应该直接知道其他对象，但应该始终协商并“找到”其他对象。作为下一阶段的基本概念，我们将使用“互联网一路向下”的类比。互联网已经证明了自己是一项伟大的工程壮举:它从仅仅4个节点扩展到数十亿个节点，而无需完全停机进行维护。也有可能我们可以随机取出10%的互联网节点，它仍然会继续运行。通过构建由这些节点或对象组成的个人计算环境，也许我们可以使其永远不需要重新启动。有趣的是，J. C. R. Licklider已经预见到程序组件需要在一个巨大的计算机网络上相互发现。从这个角度来看，我们正在努力做的是将愿景向前推进。
{"title":"Toward the future of personal computing system construction","authors":"Y. Ohshima","doi":"10.1145/2541329.2541346","DOIUrl":"https://doi.org/10.1145/2541329.2541346","url":null,"abstract":"The software for today's personal computing environments has become so complex that no single person can understand an entire system. Our group's early experiences with personal computing led us to understand that the essential model of personal computing can be expressed much more compactly. Our group engaged in a project (called the STEPS project) to materialize that vision over the last six years.\u0000 Several interesting results came out of the STEPS project. There are various meta-language implementations. A new stream-processing language called Nile was invented. The syntax of Nile allows a fully-featured vector graphics engine called Gezira to be written in a clean, mathematical manner in less than 500 lines of code. We also wrote a dynamic, yet declarative, graphical user interface framework in which we built a universal document editor.\u0000 From the experience with the STEPS project, we are exploring the next steps; one of the directions is to incorporate the idea of using multiple constraint solvers to build a system. Solvers can help stronger \"negotiation\" between objects and languages, and help the system to be written in a more declarative manner. Another direction is to take the idea of loose-coupling to the next level; objects should not know about other objects directly but should always negotiate and \"find\" other objects.\u0000 As the basic concept for this next stage, we are using the \"Internet all the way down\" analogy. The Internet has proven itself to be a great engineering feat: it scaled from just four nodes to billions of nodes without ever needing a full shutdown for maintenance. It is also likely that we can take out a random 10% of the Internet's nodes and it will still keep running. By building a personal computing environment that consists of such nodes, or objects, perhaps we can make it never need to be restarted.\u0000 Interestingly, J. C. R. Licklider already foresaw the need for program components to discover each other on a huge network of computers. From that viewpoint, what we are trying to do is to carry the vision forward.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"39 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123420389","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
This paper describes a framework devised to ease the definition and management of complex tasks on top of ALOO, a novel Concurrent Object-Oriented Programming (COOP) language rooted on agent-oriented abstractions.
{"title":"A task framework on top of a concurrent OOP language rooted on agent-oriented abstractions","authors":"Andrea Santi, A. Ricci","doi":"10.1145/2541329.2541345","DOIUrl":"https://doi.org/10.1145/2541329.2541345","url":null,"abstract":"This paper describes a framework devised to ease the definition and management of complex tasks on top of ALOO, a novel Concurrent Object-Oriented Programming (COOP) language rooted on agent-oriented abstractions.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"26 1-2 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123422140","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
In a variety of contexts -- from social media to wireless sensor networks -- we see increasingly complex patterns of communication, often characterized by having multiple senders for messages. This paper argues that existing communication mechanisms do not adequately support many-to-many communication, and proposes multicall -- a richer form of blocking broadcast -- as a possible solution. The syntax and implementation of multicall are presented, followed by examples to illustrate how multicall can be used to program many-to-many communication.
{"title":"Supporting many-to-many communication","authors":"H. Geng, Nadeem Jamali","doi":"10.1145/2541329.2541343","DOIUrl":"https://doi.org/10.1145/2541329.2541343","url":null,"abstract":"In a variety of contexts -- from social media to wireless sensor networks -- we see increasingly complex patterns of communication, often characterized by having multiple senders for messages. This paper argues that existing communication mechanisms do not adequately support many-to-many communication, and proposes multicall -- a richer form of blocking broadcast -- as a possible solution. The syntax and implementation of multicall are presented, followed by examples to illustrate how multicall can be used to program many-to-many communication.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"112 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122554097","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
In distributed object systems, it is desirable to enable migration of objects between locations, e.g., in order to support efficient resource allocation. Existing approaches build complex routing infrastructures to handle object-to-object communication, typically on top of IP, using, e.g., message forwarding chains or centralized object location servers. These solutions are costly and problematic in terms of efficiency, overhead, and correctness. We show how location independent routing can be used to implement object overlays with complex messaging behavior in a sound, fully abstract, and efficient way, on top of an abstract network of processing nodes connected point-to-point by asynchronous channels. We consider a distributed object language with futures, essentially lazy return values. Futures are challenging in this context due to the global consistency requirements they impose. The key conclusion is that execution in a decentralized, asynchronous network can preserve the standard, network-oblivious behavior of objects with futures, in the sense of contextual equivalence. To the best of our knowledge, this is the first such result in the literature. We also believe the proposed execution model may be of interest in its own right in the context of large-scale distributed computing.
{"title":"Efficient and fully abstract routing of futures in object network overlays","authors":"M. Dam, Karl Palmskog","doi":"10.1145/2541329.2541340","DOIUrl":"https://doi.org/10.1145/2541329.2541340","url":null,"abstract":"In distributed object systems, it is desirable to enable migration of objects between locations, e.g., in order to support efficient resource allocation. Existing approaches build complex routing infrastructures to handle object-to-object communication, typically on top of IP, using, e.g., message forwarding chains or centralized object location servers. These solutions are costly and problematic in terms of efficiency, overhead, and correctness. We show how location independent routing can be used to implement object overlays with complex messaging behavior in a sound, fully abstract, and efficient way, on top of an abstract network of processing nodes connected point-to-point by asynchronous channels. We consider a distributed object language with futures, essentially lazy return values. Futures are challenging in this context due to the global consistency requirements they impose. The key conclusion is that execution in a decentralized, asynchronous network can preserve the standard, network-oblivious behavior of objects with futures, in the sense of contextual equivalence. To the best of our knowledge, this is the first such result in the literature. We also believe the proposed execution model may be of interest in its own right in the context of large-scale distributed computing.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"5 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131090867","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Joeri De Koster, Stefan Marr, T. D'Hondt, T. V. Cutsem
In the past, the Actor Model has mainly been explored in a distributed context. However, more and more application developers are also starting to use it to program shared-memory multicore machines because of the safety guarantees it provides. It avoids issues such as deadlocks and race conditions by construction, and thus facilitates concurrent programming. The tradeoff is that the Actor Model sacrifices expressiveness with respect to accessing shared state because actors are fully isolated from each other (a.k.a. "shared-nothing parallelism"). There is a need for more high level synchronization mechanisms that integrate with the actor model without sacrificing the safety and liveness guarantees it provides. This paper introduces a variation on the communicating event-loops actor model called the TANK model. A tank is an actor that can expose part of its state as a shared read-only resource. The model ensures that any other actor will always observe a consistent version of that state, even in the face of concurrent updates of the actor that owns that state.
{"title":"Tanks: multiple reader, single writer actors","authors":"Joeri De Koster, Stefan Marr, T. D'Hondt, T. V. Cutsem","doi":"10.1145/2541329.2541331","DOIUrl":"https://doi.org/10.1145/2541329.2541331","url":null,"abstract":"In the past, the Actor Model has mainly been explored in a distributed context. However, more and more application developers are also starting to use it to program shared-memory multicore machines because of the safety guarantees it provides. It avoids issues such as deadlocks and race conditions by construction, and thus facilitates concurrent programming. The tradeoff is that the Actor Model sacrifices expressiveness with respect to accessing shared state because actors are fully isolated from each other (a.k.a. \"shared-nothing parallelism\"). There is a need for more high level synchronization mechanisms that integrate with the actor model without sacrificing the safety and liveness guarantees it provides. This paper introduces a variation on the communicating event-loops actor model called the TANK model. A tank is an actor that can expose part of its state as a shared read-only resource. The model ensures that any other actor will always observe a consistent version of that state, even in the face of concurrent updates of the actor that owns that state.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"61 6","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114114636","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The actor model is present in many systems that demand substantial computing resources which are often provided by multicore and multiprocessor platforms such as non-uniform memory access architectures (NUMA) and manycore processors. Yet, no mainstream actor model runtime environment (RE) currently in use takes into account the hierarchical memory characteristics of these platforms. These REs essentially assume a flat-memory space therefore not performing as well as they could. In this paper we present our proposal to improve the performance of these systems. Using knowledge about the general characteristics of actor-based applications and the underlying platform, we propose techniques spanning from memory management to scheduling and load-balancing. Based on previous work, we present our design guidelines for the RE adaptation to the Kalray MPPA-256 manycore processor.
{"title":"Improving the performance of actor model runtime environments on multicore and manycore platforms","authors":"E. Francesquini, A. Goldman, J. Méhaut","doi":"10.1145/2541329.2541342","DOIUrl":"https://doi.org/10.1145/2541329.2541342","url":null,"abstract":"The actor model is present in many systems that demand substantial computing resources which are often provided by multicore and multiprocessor platforms such as non-uniform memory access architectures (NUMA) and manycore processors. Yet, no mainstream actor model runtime environment (RE) currently in use takes into account the hierarchical memory characteristics of these platforms. These REs essentially assume a flat-memory space therefore not performing as well as they could. In this paper we present our proposal to improve the performance of these systems. Using knowledge about the general characteristics of actor-based applications and the underlying platform, we propose techniques spanning from memory management to scheduling and load-balancing. Based on previous work, we present our design guidelines for the RE adaptation to the Kalray MPPA-256 manycore processor.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"15 1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130699781","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Distributed Erlang provides mechanisms for spawning actors remotely through its remote spawn BIF. For remote spawn to function properly, the node hosting the spawned actor must share the same codebase as that of the node launching the actor. This assumption turns out to be too strong for various distributed settings. We propose a higher-level framework for the remote spawn of side-effect free actors, abstracting from codebase migration and management.
{"title":"Code management automation for Erlang remote actors","authors":"Adrian Francalanza, Tyron Zerafa","doi":"10.1145/2541329.2541344","DOIUrl":"https://doi.org/10.1145/2541329.2541344","url":null,"abstract":"Distributed Erlang provides mechanisms for spawning actors remotely through its remote spawn BIF. For remote spawn to function properly, the node hosting the spawned actor must share the same codebase as that of the node launching the actor. This assumption turns out to be too strong for various distributed settings. We propose a higher-level framework for the remote spawn of side-effect free actors, abstracting from codebase migration and management.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"14 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132927347","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Dynamic load balancing is critical in achieving high performance in parallel systems, especially for applications with unpredictable workloads. Traditional load balancing approaches -- such as work-sharing and work-stealing -- often assume that the computations can be divided into smaller computations based on some granularity. These approaches do not scale when the computations are not dividable and their sizes are highly variant. In this paper, we present a novel approach -- founded in the Actor model known for its programmability -- for dynamically load-balancing non-uniform parallel computations. Specifically, our approach is to explicitly reason about resource requirements and commitments at run-time in order to make fine-grained scheduling decisions. We prototype our approach by extending an efficient Java implementation of Actors, ActorFoundry. We have also implemented a tuner which dynamically balances the resources used by the computations vs. those used by the reasoning mechanism, essentially balancing the quality of scheduling against the resources needed for achieving it. We propose a new benchmark -- the Unbalanced Cobwebbed Tree (UCT) -- to fairly compare our approach to existing approaches, which captures the non-uniform nature of computations. Experimental results show that despite the higher overhead of providing Actors' programmability features, for a diverse enough set of computations, our approach outperforms both work-sharing and work-stealing approaches, and shows better scalability.
{"title":"Load balancing non-uniform parallel computations","authors":"Xinghui Zhao, Nadeem Jamali","doi":"10.1145/2541329.2541337","DOIUrl":"https://doi.org/10.1145/2541329.2541337","url":null,"abstract":"Dynamic load balancing is critical in achieving high performance in parallel systems, especially for applications with unpredictable workloads. Traditional load balancing approaches -- such as work-sharing and work-stealing -- often assume that the computations can be divided into smaller computations based on some granularity. These approaches do not scale when the computations are not dividable and their sizes are highly variant. In this paper, we present a novel approach -- founded in the Actor model known for its programmability -- for dynamically load-balancing non-uniform parallel computations. Specifically, our approach is to explicitly reason about resource requirements and commitments at run-time in order to make fine-grained scheduling decisions. We prototype our approach by extending an efficient Java implementation of Actors, ActorFoundry. We have also implemented a tuner which dynamically balances the resources used by the computations vs. those used by the reasoning mechanism, essentially balancing the quality of scheduling against the resources needed for achieving it. We propose a new benchmark -- the Unbalanced Cobwebbed Tree (UCT) -- to fairly compare our approach to existing approaches, which captures the non-uniform nature of computations. Experimental results show that despite the higher overhead of providing Actors' programmability features, for a diverse enough set of computations, our approach outperforms both work-sharing and work-stealing approaches, and shows better scalability.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"45 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"117201523","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The actor model of distributed computing imposes important restrictions on concurrent computations in order to be valid. In particular, an actor language implementation must provide fairness, the property that if a system transition is infinitely often enabled, the transition must eventually happen. Fairness is fundamental to proving progress properties. We show that many properties of actor computation can be expressed and proved at an abstract level, independently of the details of a particular system of actors. As in abstract algebra, we formulate and prove theorems at the most abstract level possible, so that they can be applied at all more refined levels of the theory hierarchy. Our most useful abstract-level theorems concern persistence of actors, conditional persistence of messages, preservation of unique actor identifiers, monotonicity properties of actor local states, guaranteed message delivery, and general consequences of fairness. We apply the general actor theory to a concrete ticker and clock actor system, proving several system-specific properties, including conditional invariants and a progress theorem. We develop our framework within the Athena proof system, in which proofs are both human-readable and machine-checkable, taking advantage of it library of algebraic and relational theories.
{"title":"Structured reasoning about actor systems","authors":"D. Musser, Carlos A. Varela","doi":"10.1145/2541329.2541334","DOIUrl":"https://doi.org/10.1145/2541329.2541334","url":null,"abstract":"The actor model of distributed computing imposes important restrictions on concurrent computations in order to be valid. In particular, an actor language implementation must provide fairness, the property that if a system transition is infinitely often enabled, the transition must eventually happen. Fairness is fundamental to proving progress properties. We show that many properties of actor computation can be expressed and proved at an abstract level, independently of the details of a particular system of actors. As in abstract algebra, we formulate and prove theorems at the most abstract level possible, so that they can be applied at all more refined levels of the theory hierarchy. Our most useful abstract-level theorems concern persistence of actors, conditional persistence of messages, preservation of unique actor identifiers, monotonicity properties of actor local states, guaranteed message delivery, and general consequences of fairness. We apply the general actor theory to a concrete ticker and clock actor system, proving several system-specific properties, including conditional invariants and a progress theorem. We develop our framework within the Athena proof system, in which proofs are both human-readable and machine-checkable, taking advantage of it library of algebraic and relational theories.","PeriodicalId":287804,"journal":{"name":"Workshop on Programming based on Actors, Agents, and Decentralized Control","volume":"2 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2013-10-27","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116203385","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：