通过生成式通信组合分布式应用程序

T. Holvoet, Y. Berbers
{"title":"通过生成式通信组合分布式应用程序","authors":"T. Holvoet, Y. Berbers","doi":"10.1145/319195.319228","DOIUrl":null,"url":null,"abstract":"Component-oriented approaches to software development aim to support cost-effectiveness in building applications. Components are defined as reusable entities. In this paper, we present CO3PS, a software development method for building agent-based software. Agents coordinate through generative communication. We employ generative communication to define reusable CO3PS components. Components are entities that export object spaces, i.e. places from which they can retrieve data objects and in which they can put data objects. Components can be reused by assembling them with other components through defining a mapping of their respective object spaces. The high degree of reusability that is achieved is due to the anonymous and uncoupled nature of generative communication. 1 I n t r o d u c t i o n Various terms referring to the words component or composition have been introduced recently. The marketing value of such terms is undoubtedly one important reason, as these words have a connotat ion of \"support for distribution\" and \"reuse\" and hence for cost-effective software development. Two categories of what can generally be called component-related approaches can be distinguished. A first category is concerned with s u p p o r t i n g c o m m u n i c a t i o n between software entities that may be distributed over several hosts in a network environment. As object technology has evolved rapidly over the past decade, recent proposals in this category focus on objectto-object communication. Components in this category are hence objects, while the term composition refers to the fact that distributed objects can communicate easily, i.e. with a syntax and semantics that resemble object communication in a non-distributed environment. This is the basic starting point for systems like CORBA [Obj93], the ISO reference model of open distributed processing (RMODP) [ISO95] and Java's RMI (Remote Method Invocation) lAG96]. These approaches heavily rely on remote references. Such systems are vulnerable for dangling references and require non-trivial naming schemes: A second category of component-related approaches concerns techniques for developing reusable software, mostly referred to as \"component-oriented software development\". The underlying philosophy is the following. System requirements typically change frequently. Class hierarchies are the soul reuse mechanism supported by object-oriented languages, but it is obvious that this does not suffice for all reuse purposes. Components are defined as generic \"entities that are designed to be composed and reused\" [ND95]. Component-oriented software development methods need to define components as well as composition techniques. Composition allows to combine existing components in order to constitute more complex components or applications. Only few approaches are thoroughly discussed in the current literature. E.g. components in Darwin [MK96] (as well as in related approaches that are called \"Architectural Description Languages\") are entities for which input and output ports are identified. A composition of components consequently is the result from bindings between input and output ports of the composite entities of the component. In this paper, we propose a definition of components and composition mechanisms as part of a component-oriented software development method, called C03PS. C03PS is based on genera t ive communica t ion . Generative communication allows to achieve high reusability of components and system openness (systems can allow fragments of software to cooperate easily and successfully with new, a priori unknown entities). This paper is organised as follows. In Section 2, we describe generative cominunication. We indicate the main advantages of this coordination model, and illustrate it. Section 3 presents principles of C03PS, including definitions of agents, passive objects, agent coordination and configurations. Then we define components and composition within C03PS in Section 4. We distinguish between static composition, which shares its goals with so-called architectural description languages (ADLs), and dynamic composition, which denotes a run-time mechanism for assembling software entities. We illustrate components through an example of a master/worker setting. Finally, Section 5 presents concluding remarks. 2 G e n e r a t i v e Communica t ion Generative communication is a communication paradigm that is extensively being researched in the area of coordination [Cia90, MC94, GC92]. In generative communication, communicating entities do not exchange messages directly, but through a shared data space. Concurrent entities can drop (or \"generate\") items in the data space, and others can retrieve items from the data space using associative matching. This way of communication inherently uncouples communicating processes. A sender of a data item does not directly contact anothe.r party, and a reader only contacts the shared space when it actually requires the data. The reader does not even have to exist at the time of generation. This leads to the other major advantage of generative communication: the active entities are able to communicate although they are anonymous to each other. This uncoupled and anonymous communication style directly contributes to the design of parallel and distributed applications: uncoupled communication allows to abstract from details (such as identification and interface) of the entities that are cooperating. Instead, focus is on the coordination data that each entity requires and produces. Due to these advantages, coordination models based on generative communication are superior to message passing or trader-based schemes because these both rely on knowledge about a receiver's or server's identification. PfinOob Printer PrinUob Creator Printer Creator < shared data space > ~ Figure 1: A producer/consumer setting using generative communication. Figure 1 presents a situation for a producer/consumer setting using generative communication. A number of producer entities (called PrintJobCreators) repeatedly generate items (print jobs) that need to be consumed (printed). Consumer entities (Printers) repeatedly retrieve items from the data space and consume these. The behaviour of either entity is independent of the name or the type of the other. If, for example, another Printer is presented, it can seamlessly be added to the system without requiring existing entities to be changed. Also, if an existing Printer is eliminated, this will not affect the behaviour of the PrintJobCreators, as these do not have a direct or indirect reference to it. Linda [GC92] is a generative coordination language. It supports a minimal set of language primitives for storing and retrieving data items from a data space. 3 C o m p u t a t i o n and Coord ina t ion in C03pS C03pS [Ho197] is an object-oriented method and execution environment for developing distributed applications, based on generative communication. Distributed applications are modelled as sets of cooperating active objects, called agents. Agents perform computations by creating and manipulating passive object. Passive objects are not shared between agents and \"do not have an autonomous behaviour. The CO 3pS coordination model can shortly be explained as follows. Each agent is attached to one or more object spaces. Object spaces are particular objects which may be shared amongst agents. Agents communicate by exchanging passive objects through object spaces. They use interface operations that are defined on object spaces to achieve this. C03P5 enhances Linda mainly in three ways: ® object matching: contrary to Linda, where matching of items in the shared data space is based on the contents of record fields, object matching in C03ps is based on object types and the predicates defined by the corresponding type interfaces; the items that entities (agents) can put and retrieve from object spaces are (passive) objects; • non-blocking multi-set operations on object spaces: the operations defined on the object spaces (mainly insertion and retrieval of objects) are annotated with a time-out value; this is necessary to cope with system failures, which are not unlikely in open distributed systems; moreover, the operations are extended such that multi-sets of matching objects can be inserted in or retrieved from object spaces atomically. • multiple object spaces: having only one object space is not feasible mainly for two reasons: scalability (for a huge set of agents, one global sharedblackboard is untenable from a practical point of view) and communication structure (using one blackboard as the communication medium for multiple groups of closely related agents imposes undesirable complexity); since object spaces are the forum for communication between objects, multiple object spaces may be used for separate goals, i.e. closely related objects should use the same object space (see Figure 2); a setting consisting of several agents and object spaces is called a C03ps configurat ion.","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"55 1","pages":"0"},"PeriodicalIF":0.0000,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":"1","resultStr":"{\"title\":\"Composing distributed applications through generative communication\",\"authors\":\"T. Holvoet, Y. Berbers\",\"doi\":\"10.1145/319195.319228\",\"DOIUrl\":null,\"url\":null,\"abstract\":\"Component-oriented approaches to software development aim to support cost-effectiveness in building applications. Components are defined as reusable entities. In this paper, we present CO3PS, a software development method for building agent-based software. Agents coordinate through generative communication. We employ generative communication to define reusable CO3PS components. Components are entities that export object spaces, i.e. places from which they can retrieve data objects and in which they can put data objects. Components can be reused by assembling them with other components through defining a mapping of their respective object spaces. The high degree of reusability that is achieved is due to the anonymous and uncoupled nature of generative communication. 1 I n t r o d u c t i o n Various terms referring to the words component or composition have been introduced recently. The marketing value of such terms is undoubtedly one important reason, as these words have a connotat ion of \\\"support for distribution\\\" and \\\"reuse\\\" and hence for cost-effective software development. Two categories of what can generally be called component-related approaches can be distinguished. A first category is concerned with s u p p o r t i n g c o m m u n i c a t i o n between software entities that may be distributed over several hosts in a network environment. As object technology has evolved rapidly over the past decade, recent proposals in this category focus on objectto-object communication. Components in this category are hence objects, while the term composition refers to the fact that distributed objects can communicate easily, i.e. with a syntax and semantics that resemble object communication in a non-distributed environment. This is the basic starting point for systems like CORBA [Obj93], the ISO reference model of open distributed processing (RMODP) [ISO95] and Java's RMI (Remote Method Invocation) lAG96]. These approaches heavily rely on remote references. Such systems are vulnerable for dangling references and require non-trivial naming schemes: A second category of component-related approaches concerns techniques for developing reusable software, mostly referred to as \\\"component-oriented software development\\\". The underlying philosophy is the following. System requirements typically change frequently. Class hierarchies are the soul reuse mechanism supported by object-oriented languages, but it is obvious that this does not suffice for all reuse purposes. Components are defined as generic \\\"entities that are designed to be composed and reused\\\" [ND95]. Component-oriented software development methods need to define components as well as composition techniques. Composition allows to combine existing components in order to constitute more complex components or applications. Only few approaches are thoroughly discussed in the current literature. E.g. components in Darwin [MK96] (as well as in related approaches that are called \\\"Architectural Description Languages\\\") are entities for which input and output ports are identified. A composition of components consequently is the result from bindings between input and output ports of the composite entities of the component. In this paper, we propose a definition of components and composition mechanisms as part of a component-oriented software development method, called C03PS. C03PS is based on genera t ive communica t ion . Generative communication allows to achieve high reusability of components and system openness (systems can allow fragments of software to cooperate easily and successfully with new, a priori unknown entities). This paper is organised as follows. In Section 2, we describe generative cominunication. We indicate the main advantages of this coordination model, and illustrate it. Section 3 presents principles of C03PS, including definitions of agents, passive objects, agent coordination and configurations. Then we define components and composition within C03PS in Section 4. We distinguish between static composition, which shares its goals with so-called architectural description languages (ADLs), and dynamic composition, which denotes a run-time mechanism for assembling software entities. We illustrate components through an example of a master/worker setting. Finally, Section 5 presents concluding remarks. 2 G e n e r a t i v e Communica t ion Generative communication is a communication paradigm that is extensively being researched in the area of coordination [Cia90, MC94, GC92]. In generative communication, communicating entities do not exchange messages directly, but through a shared data space. Concurrent entities can drop (or \\\"generate\\\") items in the data space, and others can retrieve items from the data space using associative matching. This way of communication inherently uncouples communicating processes. A sender of a data item does not directly contact anothe.r party, and a reader only contacts the shared space when it actually requires the data. The reader does not even have to exist at the time of generation. This leads to the other major advantage of generative communication: the active entities are able to communicate although they are anonymous to each other. This uncoupled and anonymous communication style directly contributes to the design of parallel and distributed applications: uncoupled communication allows to abstract from details (such as identification and interface) of the entities that are cooperating. Instead, focus is on the coordination data that each entity requires and produces. Due to these advantages, coordination models based on generative communication are superior to message passing or trader-based schemes because these both rely on knowledge about a receiver's or server's identification. PfinOob Printer PrinUob Creator Printer Creator < shared data space > ~ Figure 1: A producer/consumer setting using generative communication. Figure 1 presents a situation for a producer/consumer setting using generative communication. A number of producer entities (called PrintJobCreators) repeatedly generate items (print jobs) that need to be consumed (printed). Consumer entities (Printers) repeatedly retrieve items from the data space and consume these. The behaviour of either entity is independent of the name or the type of the other. If, for example, another Printer is presented, it can seamlessly be added to the system without requiring existing entities to be changed. Also, if an existing Printer is eliminated, this will not affect the behaviour of the PrintJobCreators, as these do not have a direct or indirect reference to it. Linda [GC92] is a generative coordination language. It supports a minimal set of language primitives for storing and retrieving data items from a data space. 3 C o m p u t a t i o n and Coord ina t ion in C03pS C03pS [Ho197] is an object-oriented method and execution environment for developing distributed applications, based on generative communication. Distributed applications are modelled as sets of cooperating active objects, called agents. Agents perform computations by creating and manipulating passive object. Passive objects are not shared between agents and \\\"do not have an autonomous behaviour. The CO 3pS coordination model can shortly be explained as follows. Each agent is attached to one or more object spaces. Object spaces are particular objects which may be shared amongst agents. Agents communicate by exchanging passive objects through object spaces. They use interface operations that are defined on object spaces to achieve this. C03P5 enhances Linda mainly in three ways: ® object matching: contrary to Linda, where matching of items in the shared data space is based on the contents of record fields, object matching in C03ps is based on object types and the predicates defined by the corresponding type interfaces; the items that entities (agents) can put and retrieve from object spaces are (passive) objects; • non-blocking multi-set operations on object spaces: the operations defined on the object spaces (mainly insertion and retrieval of objects) are annotated with a time-out value; this is necessary to cope with system failures, which are not unlikely in open distributed systems; moreover, the operations are extended such that multi-sets of matching objects can be inserted in or retrieved from object spaces atomically. • multiple object spaces: having only one object space is not feasible mainly for two reasons: scalability (for a huge set of agents, one global sharedblackboard is untenable from a practical point of view) and communication structure (using one blackboard as the communication medium for multiple groups of closely related agents imposes undesirable complexity); since object spaces are the forum for communication between objects, multiple object spaces may be used for separate goals, i.e. closely related objects should use the same object space (see Figure 2); a setting consisting of several agents and object spaces is called a C03ps configurat ion.\",\"PeriodicalId\":335784,\"journal\":{\"name\":\"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications\",\"volume\":\"55 1\",\"pages\":\"0\"},\"PeriodicalIF\":0.0000,\"publicationDate\":\"1998-09-07\",\"publicationTypes\":\"Journal Article\",\"fieldsOfStudy\":null,\"isOpenAccess\":false,\"openAccessPdf\":\"\",\"citationCount\":\"1\",\"resultStr\":null,\"platform\":\"Semanticscholar\",\"paperid\":null,\"PeriodicalName\":\"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications\",\"FirstCategoryId\":\"1085\",\"ListUrlMain\":\"https://doi.org/10.1145/319195.319228\",\"RegionNum\":0,\"RegionCategory\":null,\"ArticlePicture\":[],\"TitleCN\":null,\"AbstractTextCN\":null,\"PMCID\":null,\"EPubDate\":\"\",\"PubModel\":\"\",\"JCR\":\"\",\"JCRName\":\"\",\"Score\":null,\"Total\":0}","platform":"Semanticscholar","paperid":null,"PeriodicalName":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","FirstCategoryId":"1085","ListUrlMain":"https://doi.org/10.1145/319195.319228","RegionNum":0,"RegionCategory":null,"ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":null,"EPubDate":"","PubModel":"","JCR":"","JCRName":"","Score":null,"Total":0}
引用次数: 1

摘要

面向组件的软件开发方法旨在支持构建应用程序的成本效益。组件被定义为可重用的实体。本文提出了一种基于agent的软件开发方法——CO3PS。代理通过生成式通信进行协调。我们使用生成式通信来定义可重用的CO3PS组件。组件是导出对象空间的实体,即它们可以从中检索数据对象并将数据对象放入其中的位置。通过定义各自对象空间的映射,可以将组件与其他组件组装在一起,从而重用组件。由于生成式通信的匿名性和解耦性,实现了高度的可重用性。最近引入了许多与成分或组成有关的术语。这些术语的市场价值无疑是一个重要的原因,因为这些词具有“支持分发”和“重用”的内涵,因此具有成本效益的软件开发。可以将通常称为组件相关方法的两类方法区分开来。第一类涉及的是在网络环境中可能分布在多台主机上的软件实体之间的数据传输。随着对象技术在过去十年中迅速发展,这一类别中最近的建议集中在对象与对象之间的通信。因此,此类别中的组件是对象,而术语组合指的是分布式对象可以轻松通信的事实,即使用类似于非分布式环境中的对象通信的语法和语义。这是像CORBA [Obj93]、开放分布式处理(RMODP)的ISO参考模型[ISO95]和Java的RMI(远程方法调用)lAG96]这样的系统的基本出发点。这些方法严重依赖于远程引用。这样的系统容易受到悬空引用的攻击,并且需要非平凡的命名方案:第二类与组件相关的方法涉及开发可重用软件的技术,通常称为“面向组件的软件开发”。其基本理念如下。系统需求通常会频繁变化。类层次结构是面向对象语言支持的核心重用机制,但很明显,这并不足以满足所有重用目的。组件被定义为通用的“设计用于组合和重用的实体”[ND95]。面向组件的软件开发方法需要定义组件以及组合技术。组合允许组合现有组件,以构成更复杂的组件或应用程序。在目前的文献中,只有少数几种方法得到了深入的讨论。例如,Darwin [MK96]中的组件(以及被称为“架构描述语言”的相关方法)是识别输入和输出端口的实体。因此,组件的组合是组件组合实体的输入和输出端口之间绑定的结果。在本文中,我们提出了组件和组合机制的定义,作为面向组件的软件开发方法(称为C03PS)的一部分。C03PS基于通用实时通信技术。生成式通信允许实现组件的高可重用性和系统开放性(系统可以允许软件片段轻松成功地与新的先验未知实体合作)。本文组织如下。在第2节中,我们描述了生成式沟通。指出了该协调模型的主要优点,并对其进行了说明。第3节介绍了C03PS的原理,包括代理的定义、被动对象、代理协调和配置。然后,我们在第4节中定义C03PS中的组件和组合。我们区分静态组合和动态组合,前者与所谓的体系结构描述语言(adl)共享其目标,后者表示用于组装软件实体的运行时机制。我们通过一个主/辅助设置的示例来说明组件。最后,第五节是结束语。生成式通信(Generative communication)是一种在协调领域得到广泛研究的通信范式[Cia90, MC94, GC92]。在生成式通信中,通信实体不直接交换消息,而是通过共享的数据空间进行交换。并发实体可以在数据空间中删除(或“生成”)项,其他实体可以使用关联匹配从数据空间检索项。这种沟通方式本质上使沟通过程分离。数据项的发送者不直接与另一个发送者联系。R方,并且阅读器只在实际需要数据时才与共享空间联系。 读者甚至不必在产生时就存在。这导致了生成通信的另一个主要优势:活动实体能够进行通信,尽管它们彼此是匿名的。这种非耦合和匿名通信风格直接有助于并行和分布式应用程序的设计:非耦合通信允许从合作实体的细节(如标识和接口)中抽象出来。相反,重点是每个实体需要和产生的协调数据。由于这些优点,基于生成通信的协调模型优于消息传递或基于交易的方案,因为它们都依赖于关于接收者或服务器身份的知识。PfinOob Printer PrinUob Creator Printer Creator <共享数据空间> ~图1:使用生成通信的生产者/消费者设置。图1展示了使用生成式通信的生产者/消费者设置的情况。许多生产者实体(称为PrintJobCreators)重复生成需要消费(打印)的项目(打印作业)。消费者实体(打印机)反复地从数据空间检索项目并使用这些项目。任何一个实体的行为都独立于另一个实体的名称或类型。例如,如果呈现另一个Printer,则可以无缝地将其添加到系统中,而无需更改现有实体。另外,如果现有的打印机被删除,这不会影响printjobcreator的行为,因为它们没有对它的直接或间接引用。Linda [GC92]是一种生成式协调语言。它支持一组最小的语言原语,用于从数据空间存储和检索数据项。C03pS [Ho197]是一种基于生成式通信的面向对象方法和用于开发分布式应用程序的执行环境。分布式应用程序被建模为一组相互协作的活动对象(称为代理)。代理通过创建和操作被动对象来执行计算。被动对象不会在代理之间共享,并且“没有自主行为”。CO - 3pS协调模型可以简单地解释如下。每个代理都附加到一个或多个对象空间。对象空间是可以在代理之间共享的特定对象。代理通过对象空间交换被动对象进行通信。它们使用在对象空间上定义的接口操作来实现这一点。C03P5主要从三个方面对Linda进行了增强:对象匹配:与Linda不同,Linda是根据记录字段的内容对共享数据空间中的项进行匹配,而C03ps中的对象匹配是根据对象类型和相应类型接口定义的谓词进行匹配;实体(代理)可以从对象空间中放置和检索的项目是(被动)对象;•对象空间上的非阻塞多集操作:对象空间上定义的操作(主要是对象的插入和检索)都带有超时值注释;这对于处理系统故障是必要的,这在开放的分布式系统中是不可能的;此外,对操作进行了扩展,使得可以在对象空间中自动插入或从对象空间中检索多组匹配对象。•多对象空间:只有一个对象空间是不可行的,主要有两个原因:可扩展性(对于一个庞大的代理集,从实用的角度来看,一个全局共享黑板是站不下去的)和通信结构(使用一个黑板作为多组密切相关的代理的通信媒介会带来不必要的复杂性);由于对象空间是对象之间交流的论坛,多个对象空间可以用于单独的目标,即密切相关的对象应该使用相同的对象空间(见图2);由多个代理和对象空间组成的设置称为C03ps配置。
本文章由计算机程序翻译,如有差异,请以英文原文为准。
查看原文
分享 分享
微信好友 朋友圈 QQ好友 复制链接
本刊更多论文
Composing distributed applications through generative communication
Component-oriented approaches to software development aim to support cost-effectiveness in building applications. Components are defined as reusable entities. In this paper, we present CO3PS, a software development method for building agent-based software. Agents coordinate through generative communication. We employ generative communication to define reusable CO3PS components. Components are entities that export object spaces, i.e. places from which they can retrieve data objects and in which they can put data objects. Components can be reused by assembling them with other components through defining a mapping of their respective object spaces. The high degree of reusability that is achieved is due to the anonymous and uncoupled nature of generative communication. 1 I n t r o d u c t i o n Various terms referring to the words component or composition have been introduced recently. The marketing value of such terms is undoubtedly one important reason, as these words have a connotat ion of "support for distribution" and "reuse" and hence for cost-effective software development. Two categories of what can generally be called component-related approaches can be distinguished. A first category is concerned with s u p p o r t i n g c o m m u n i c a t i o n between software entities that may be distributed over several hosts in a network environment. As object technology has evolved rapidly over the past decade, recent proposals in this category focus on objectto-object communication. Components in this category are hence objects, while the term composition refers to the fact that distributed objects can communicate easily, i.e. with a syntax and semantics that resemble object communication in a non-distributed environment. This is the basic starting point for systems like CORBA [Obj93], the ISO reference model of open distributed processing (RMODP) [ISO95] and Java's RMI (Remote Method Invocation) lAG96]. These approaches heavily rely on remote references. Such systems are vulnerable for dangling references and require non-trivial naming schemes: A second category of component-related approaches concerns techniques for developing reusable software, mostly referred to as "component-oriented software development". The underlying philosophy is the following. System requirements typically change frequently. Class hierarchies are the soul reuse mechanism supported by object-oriented languages, but it is obvious that this does not suffice for all reuse purposes. Components are defined as generic "entities that are designed to be composed and reused" [ND95]. Component-oriented software development methods need to define components as well as composition techniques. Composition allows to combine existing components in order to constitute more complex components or applications. Only few approaches are thoroughly discussed in the current literature. E.g. components in Darwin [MK96] (as well as in related approaches that are called "Architectural Description Languages") are entities for which input and output ports are identified. A composition of components consequently is the result from bindings between input and output ports of the composite entities of the component. In this paper, we propose a definition of components and composition mechanisms as part of a component-oriented software development method, called C03PS. C03PS is based on genera t ive communica t ion . Generative communication allows to achieve high reusability of components and system openness (systems can allow fragments of software to cooperate easily and successfully with new, a priori unknown entities). This paper is organised as follows. In Section 2, we describe generative cominunication. We indicate the main advantages of this coordination model, and illustrate it. Section 3 presents principles of C03PS, including definitions of agents, passive objects, agent coordination and configurations. Then we define components and composition within C03PS in Section 4. We distinguish between static composition, which shares its goals with so-called architectural description languages (ADLs), and dynamic composition, which denotes a run-time mechanism for assembling software entities. We illustrate components through an example of a master/worker setting. Finally, Section 5 presents concluding remarks. 2 G e n e r a t i v e Communica t ion Generative communication is a communication paradigm that is extensively being researched in the area of coordination [Cia90, MC94, GC92]. In generative communication, communicating entities do not exchange messages directly, but through a shared data space. Concurrent entities can drop (or "generate") items in the data space, and others can retrieve items from the data space using associative matching. This way of communication inherently uncouples communicating processes. A sender of a data item does not directly contact anothe.r party, and a reader only contacts the shared space when it actually requires the data. The reader does not even have to exist at the time of generation. This leads to the other major advantage of generative communication: the active entities are able to communicate although they are anonymous to each other. This uncoupled and anonymous communication style directly contributes to the design of parallel and distributed applications: uncoupled communication allows to abstract from details (such as identification and interface) of the entities that are cooperating. Instead, focus is on the coordination data that each entity requires and produces. Due to these advantages, coordination models based on generative communication are superior to message passing or trader-based schemes because these both rely on knowledge about a receiver's or server's identification. PfinOob Printer PrinUob Creator Printer Creator < shared data space > ~ Figure 1: A producer/consumer setting using generative communication. Figure 1 presents a situation for a producer/consumer setting using generative communication. A number of producer entities (called PrintJobCreators) repeatedly generate items (print jobs) that need to be consumed (printed). Consumer entities (Printers) repeatedly retrieve items from the data space and consume these. The behaviour of either entity is independent of the name or the type of the other. If, for example, another Printer is presented, it can seamlessly be added to the system without requiring existing entities to be changed. Also, if an existing Printer is eliminated, this will not affect the behaviour of the PrintJobCreators, as these do not have a direct or indirect reference to it. Linda [GC92] is a generative coordination language. It supports a minimal set of language primitives for storing and retrieving data items from a data space. 3 C o m p u t a t i o n and Coord ina t ion in C03pS C03pS [Ho197] is an object-oriented method and execution environment for developing distributed applications, based on generative communication. Distributed applications are modelled as sets of cooperating active objects, called agents. Agents perform computations by creating and manipulating passive object. Passive objects are not shared between agents and "do not have an autonomous behaviour. The CO 3pS coordination model can shortly be explained as follows. Each agent is attached to one or more object spaces. Object spaces are particular objects which may be shared amongst agents. Agents communicate by exchanging passive objects through object spaces. They use interface operations that are defined on object spaces to achieve this. C03P5 enhances Linda mainly in three ways: ® object matching: contrary to Linda, where matching of items in the shared data space is based on the contents of record fields, object matching in C03ps is based on object types and the predicates defined by the corresponding type interfaces; the items that entities (agents) can put and retrieve from object spaces are (passive) objects; • non-blocking multi-set operations on object spaces: the operations defined on the object spaces (mainly insertion and retrieval of objects) are annotated with a time-out value; this is necessary to cope with system failures, which are not unlikely in open distributed systems; moreover, the operations are extended such that multi-sets of matching objects can be inserted in or retrieved from object spaces atomically. • multiple object spaces: having only one object space is not feasible mainly for two reasons: scalability (for a huge set of agents, one global sharedblackboard is untenable from a practical point of view) and communication structure (using one blackboard as the communication medium for multiple groups of closely related agents imposes undesirable complexity); since object spaces are the forum for communication between objects, multiple object spaces may be used for separate goals, i.e. closely related objects should use the same object space (see Figure 2); a setting consisting of several agents and object spaces is called a C03ps configurat ion.
求助全文
通过发布文献求助,成功后即可免费获取论文全文。 去求助
来源期刊
自引率
0.00%
发文量
0
期刊最新文献
The Porcupine scalable mail server Replicated invocations in wide-area systems Irreproducible benchmarks might be sometimes helpful An asynchronous distributed systems platform for heterogeneous environments Dual objects—an object model for distributed system programming
×
引用
GB/T 7714-2015
复制
MLA
复制
APA
复制
导出至
BibTeX EndNote RefMan NoteFirst NoteExpress
×
×
提示
您的信息不完整,为了账户安全,请先补充。
现在去补充
×
提示
您因"违规操作"
具体请查看互助需知
我知道了
×
提示
现在去查看 取消
×
提示
确定
0
微信
客服QQ
Book学术公众号 扫码关注我们
反馈
×
意见反馈
请填写您的意见或建议
请填写您的手机或邮箱
已复制链接
已复制链接
快去分享给好友吧!
我知道了
×
扫码分享
扫码分享
Book学术官方微信
Book学术文献互助
Book学术文献互助群
群 号:481959085
Book学术
文献互助 智能选刊 最新文献 互助须知 联系我们:info@booksci.cn
Book学术提供免费学术资源搜索服务,方便国内外学者检索中英文文献。致力于提供最便捷和优质的服务体验。
Copyright © 2023 Book学术 All rights reserved.
ghs 京公网安备 11010802042870号 京ICP备2023020795号-1