The thesis of this paper is that, using our eventbased development principles, components that were not designed to interoperate, can be made to work together quickly and easily. The only requirement is that each component must be made event-based by adding an interface for registering interest in events and an interface for injecting actions. A component noti es an event to a distributed client if the parameters of an event, internal to the component, match the parameters of a particular registration. Heterogeneous components can be federated using event-based rules; rules can respond to events from any component by injecting actions into any other component. We show that the event paradigm is scalable by illustrating how event-based components can be located worldwide, using a federation of event brokers. Additionally, we illustrate with 3 event-based systems we have developed: a component-based multimedia system, a multi-user virtual worlds system and an augmented reality system for mobile users. Finally, we show how the event paradigm is also scalable enough to allow event federation of entire systems, not just single components. We illustrate by showing how we have federated the operation of the 3 featured eventbased systems. This enables, for example, real-world mobile users to appear as avatars in the appropriate locations in the VR world, and for these avatars to move in response to actual user movements. 1 Principles of Event-based Systems This section introduces distributed systems development using events. The framework presented here uses events to glue" together components. By using events as a uniform way of informing other components of activities that have occurred, systems/applications can be built around a generic eventresponse paradigm. Using this approach, the entire Internet can become a plug-and-play domain. An event is an asynchronous message containing parametrised details of an activity that has occurred within a component, or has been detected by the component. Services publish details of classes of event they actively monitor for, clients register interest with services, and services notify clients, as appropriate. Single events, or events as part of an ordered combination of events, noti ed to clients, can be used to trigger further actions within the system/application. Using events as the uniform interchange of activity between the possibly distributed components, simplies the construction of a complex system/application. Our recent work is making fundamental contributions to the diÆcult problem of how to compose or federate existing systems to achieve interoperability. A related problem that is relevant within a single domain is how to add new object types (in our case, event classes) to a dynamically running system. In this paper, we use the term active system to describe a large system or application composed of components interoperating via event federation. 1.1 Components and Glue Event-based programming relies
{"title":"Using events for the scalable federation of heterogeneous components","authors":"J. Bates, J. Bacon, K. Moody, M. D. Spiteri","doi":"10.1145/319195.319205","DOIUrl":"https://doi.org/10.1145/319195.319205","url":null,"abstract":"The thesis of this paper is that, using our eventbased development principles, components that were not designed to interoperate, can be made to work together quickly and easily. The only requirement is that each component must be made event-based by adding an interface for registering interest in events and an interface for injecting actions. A component noti es an event to a distributed client if the parameters of an event, internal to the component, match the parameters of a particular registration. Heterogeneous components can be federated using event-based rules; rules can respond to events from any component by injecting actions into any other component. We show that the event paradigm is scalable by illustrating how event-based components can be located worldwide, using a federation of event brokers. Additionally, we illustrate with 3 event-based systems we have developed: a component-based multimedia system, a multi-user virtual worlds system and an augmented reality system for mobile users. Finally, we show how the event paradigm is also scalable enough to allow event federation of entire systems, not just single components. We illustrate by showing how we have federated the operation of the 3 featured eventbased systems. This enables, for example, real-world mobile users to appear as avatars in the appropriate locations in the VR world, and for these avatars to move in response to actual user movements. 1 Principles of Event-based Systems This section introduces distributed systems development using events. The framework presented here uses events to glue\" together components. By using events as a uniform way of informing other components of activities that have occurred, systems/applications can be built around a generic eventresponse paradigm. Using this approach, the entire Internet can become a plug-and-play domain. An event is an asynchronous message containing parametrised details of an activity that has occurred within a component, or has been detected by the component. Services publish details of classes of event they actively monitor for, clients register interest with services, and services notify clients, as appropriate. Single events, or events as part of an ordered combination of events, noti ed to clients, can be used to trigger further actions within the system/application. Using events as the uniform interchange of activity between the possibly distributed components, simplies the construction of a complex system/application. Our recent work is making fundamental contributions to the diÆcult problem of how to compose or federate existing systems to achieve interoperability. A related problem that is relevant within a single domain is how to add new object types (in our case, event classes) to a dynamically running system. In this paper, we use the term active system to describe a large system or application composed of components interoperating via event federation. 1.1 Components and Glue Event-based programming relies ","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"32 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122283865","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}
Hermann Härtig, Robert Baumgartl, M. Borriss, Claude-Joachim Hamann, Michael Hohmuth, F. Mehnert, Lars Reuther, S. Schönberg, J. Wolter
The characterising new requirement for distributed multimedia applications is the coexistence of dynamic real-time and non-real-time applications on hosts and networks. While some networks (e.g., ATM) in principle have the capability to reserve bandwidth on shared links, host systems usually do not. DROPS (Dresden Real-time OPerating System) is being built to remedy that situation by providing resource managers that allow the reservation of resources in advance and enforce that reservations. It allows the coexistence of timesharing applications (with no reservations) and real-time applications (with reservations). By outlining the principle architecture, some design decisions, and first results, the paper demonstrates how these objectives can be met using straightforward OS technology. It argues that middleware for diverse platforms cannot meet these objectives efficiently without proper core operating system support.
{"title":"DROPS: OS support for distributed multimedia applications","authors":"Hermann Härtig, Robert Baumgartl, M. Borriss, Claude-Joachim Hamann, Michael Hohmuth, F. Mehnert, Lars Reuther, S. Schönberg, J. Wolter","doi":"10.1145/319195.319226","DOIUrl":"https://doi.org/10.1145/319195.319226","url":null,"abstract":"The characterising new requirement for distributed multimedia applications is the coexistence of dynamic real-time and non-real-time applications on hosts and networks. While some networks (e.g., ATM) in principle have the capability to reserve bandwidth on shared links, host systems usually do not. DROPS (Dresden Real-time OPerating System) is being built to remedy that situation by providing resource managers that allow the reservation of resources in advance and enforce that reservations. It allows the coexistence of timesharing applications (with no reservations) and real-time applications (with reservations). By outlining the principle architecture, some design decisions, and first results, the paper demonstrates how these objectives can be met using straightforward OS technology. It argues that middleware for diverse platforms cannot meet these objectives efficiently without proper core operating system support.","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"42 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116360918","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}
S. Mitchell, Hani Naguib, G. Coulouris, T. Kindberg
Distributed multimedia systems are potentially subject to frequent and ongoing evolution of application structures. In such systems it is often unacceptable for reconfigurations to fail or to only partially succeed. This paper describes the reconfiguration architecture of the DJINN multimedia programming framework. We introduce the concept of multimedia transactions for structuring changes into atomic units that preserve application consistency and extend these with the smoothness condition to maintain temporal as well as data integrity across reconfigurations. We present a technique for scheduling configuration changes that trades off the perceived level of smoothness against the available resources and the desired timeliness of the reconfiguration.
{"title":"Dynamically reconfiguring multimedia components: a model-based approach","authors":"S. Mitchell, Hani Naguib, G. Coulouris, T. Kindberg","doi":"10.1145/319195.319202","DOIUrl":"https://doi.org/10.1145/319195.319202","url":null,"abstract":"Distributed multimedia systems are potentially subject to frequent and ongoing evolution of application structures. In such systems it is often unacceptable for reconfigurations to fail or to only partially succeed. This paper describes the reconfiguration architecture of the DJINN multimedia programming framework. We introduce the concept of multimedia transactions for structuring changes into atomic units that preserve application consistency and extend these with the smoothness condition to maintain temporal as well as data integrity across reconfigurations. We present a technique for scheduling configuration changes that trades off the perceived level of smoothness against the available resources and the desired timeliness of the reconfiguration.","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"29 5","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131623537","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}
J. Liedtke, N. Islam, T. Jaeger, Vsevolod Panteleenko, Yoonho Park
There are 100+ million computers in the world. Even smaller organizations have easily 100+ machines; 10,000+ are typical for medium-sized organizations like a university or a bank. Current network technology is so ubiqitious and so powerful that we increasingly use these crowds of computers as one “technical being” instead of thinking of them as single machines. Consequently, we try to support distributed applications, not only by moving data around but also by remote execution of downloaded/uploaded code (applets, servlets) and even dynamically migrating active objects, i.e., curently executing programs (agents, load distribution). Unfortunately, not all of these 100+ million machines are compatible with each other. Currently, in the workstation/PC/NC segment, we see about 7 different hardware architectures: x86, PowerPC, Alpha, Mips, Sparc, PA-Risc, 68K. Some architectures are likely to disappear over time, e.g. 68K; however, new ones will show up (perhaps Intel’s IA-64). Heterogeneity will probably remain a problem over the next decade. More or less compatible OS APIs and tools, in particular compilers, help to move a source program from an x-machine to a y-machine. Moving a compiled program is harder; moving a currently executing program (migrating) between x and y is the hardest. One approach to move compiled programs between architectures is based on architectureindependent intermediate representations for compiled programs, e.g. Java bytecodes [10] or slim binaries [6]. However, it does not seem likely that in the near future all compilers will use a single intermediate language. (The language community has dreamed about the UNCOL (unitary compiler language) approach for nearly 40 years [15]. The UNCOL idea is to have a single language-independent code generation interface and thus architectureindependent compilers.) So the mentioned approach is restricted to certain programming languages and does not (yet?) give us general mobility for compiled programs. To solve the inter-architecture mobility problem for portable agents and for load distribution, we must be able to migrate a currently executing program with all its data, including temporary stack and heap data. A first approach to this problem is the ubiquitous interpreter. For example, the Aglets system [9] uses a JVM; Ara [11] uses Tcl. A second approach [14] is based on generating special (native) code that permits migration at certain synchronization points (“bus stops”) (Per architecture, a native-code version was generated when the source was compiled.). Similar to the techniques mentioned in the previous paragraph, both solutions suffer from the fact that they are specific to a single language.
{"title":"An unconventional proposal: using the x86 architecture as the ubiquitous virtual standard architecture","authors":"J. Liedtke, N. Islam, T. Jaeger, Vsevolod Panteleenko, Yoonho Park","doi":"10.1145/319195.319231","DOIUrl":"https://doi.org/10.1145/319195.319231","url":null,"abstract":"There are 100+ million computers in the world. Even smaller organizations have easily 100+ machines; 10,000+ are typical for medium-sized organizations like a university or a bank. Current network technology is so ubiqitious and so powerful that we increasingly use these crowds of computers as one “technical being” instead of thinking of them as single machines. Consequently, we try to support distributed applications, not only by moving data around but also by remote execution of downloaded/uploaded code (applets, servlets) and even dynamically migrating active objects, i.e., curently executing programs (agents, load distribution). Unfortunately, not all of these 100+ million machines are compatible with each other. Currently, in the workstation/PC/NC segment, we see about 7 different hardware architectures: x86, PowerPC, Alpha, Mips, Sparc, PA-Risc, 68K. Some architectures are likely to disappear over time, e.g. 68K; however, new ones will show up (perhaps Intel’s IA-64). Heterogeneity will probably remain a problem over the next decade. More or less compatible OS APIs and tools, in particular compilers, help to move a source program from an x-machine to a y-machine. Moving a compiled program is harder; moving a currently executing program (migrating) between x and y is the hardest. One approach to move compiled programs between architectures is based on architectureindependent intermediate representations for compiled programs, e.g. Java bytecodes [10] or slim binaries [6]. However, it does not seem likely that in the near future all compilers will use a single intermediate language. (The language community has dreamed about the UNCOL (unitary compiler language) approach for nearly 40 years [15]. The UNCOL idea is to have a single language-independent code generation interface and thus architectureindependent compilers.) So the mentioned approach is restricted to certain programming languages and does not (yet?) give us general mobility for compiled programs. To solve the inter-architecture mobility problem for portable agents and for load distribution, we must be able to migrate a currently executing program with all its data, including temporary stack and heap data. A first approach to this problem is the ubiquitous interpreter. For example, the Aglets system [9] uses a JVM; Ara [11] uses Tcl. A second approach [14] is based on generating special (native) code that permits migration at certain synchronization points (“bus stops”) (Per architecture, a native-code version was generated when the source was compiled.). Similar to the techniques mentioned in the previous paragraph, both solutions suffer from the fact that they are specific to a single language.","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"265 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"134209820","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}
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 L
{"title":"Composing distributed applications through generative communication","authors":"T. Holvoet, Y. Berbers","doi":"10.1145/319195.319228","DOIUrl":"https://doi.org/10.1145/319195.319228","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 L","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.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133875725","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}
Writing efficient applications is difficult for two reasons. A given problem domain often demands a particular programming language and execution environment. Together these provide a "paradigm" in which the programmer can concentrate on the problem rather than the implementation. Secondly, most operating systems have a rigid architecture. Adapting them to the needs of modern applications, such as cooperative work, embedded systems, and multimedia, requires ad-hoc solutions, increasing development costs and reducing both reliability and efficiency. We present a multi-language, hardware independent, execution platform, that is dynamically extensible and adaptable to each application's needs. An application is associated with a virtual machine decription, that allows to translate the application into a language neutral internal representation. The novel virtual machine architecture described in this paper allows programs written in an arbitrary bytecoded language to be executed safely and efficiently. Its single execution model provides interoperability, and effectively promotes reuse of existing software modules. 1 I n t r o d u c t i o n Applications are becoming larger, clumsier, and buggier. Notable examples are Netscape and Microsoft Office, which contain their own implementat ions of typical operat ing-system services: distribution, QoS, security, and so on. Such services belong in the operat ing system. "Also with the LIP6, Paris.
{"title":"A dynamically configurable, multi-language execution platform","authors":"B. Folliot, Ian Piumarta, F. Riccardi","doi":"10.1145/319195.319222","DOIUrl":"https://doi.org/10.1145/319195.319222","url":null,"abstract":"Writing efficient applications is difficult for two reasons. A given problem domain often demands a particular programming language and execution environment. Together these provide a \"paradigm\" in which the programmer can concentrate on the problem rather than the implementation. Secondly, most operating systems have a rigid architecture. Adapting them to the needs of modern applications, such as cooperative work, embedded systems, and multimedia, requires ad-hoc solutions, increasing development costs and reducing both reliability and efficiency. We present a multi-language, hardware independent, execution platform, that is dynamically extensible and adaptable to each application's needs. An application is associated with a virtual machine decription, that allows to translate the application into a language neutral internal representation. The novel virtual machine architecture described in this paper allows programs written in an arbitrary bytecoded language to be executed safely and efficiently. Its single execution model provides interoperability, and effectively promotes reuse of existing software modules. 1 I n t r o d u c t i o n Applications are becoming larger, clumsier, and buggier. Notable examples are Netscape and Microsoft Office, which contain their own implementat ions of typical operat ing-system services: distribution, QoS, security, and so on. Such services belong in the operat ing system. \"Also with the LIP6, Paris.","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"30 24 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125681428","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}
There is growing interest in the use of general-purpose even t notification services as “middleware” for gluing together independently-developed distributed applications. This approach was first discussed by Oki et.al.in 1993 [14], where an early version of the (now) TIBCO Information Bus [20] was described. Since then, many other commercial products have been developed that accept events from event suppliers (publishers) and deliver them to event consumers (subscribers). Publish-subscribe mechanisms have also been retro-fitted to existing middleware products, including pe rsistent message queue products and TP monitors. There is also standards work in this area, including the CORBA Event Service [15] and more recently the CORBA Notification Service [16], a feature-enriched version of the Event Service. Despite all of these products and the standardization efforts, and despite the fact that event-driven computation i s not a new idea, there has been relatively little work on highlevel constructs for event services. The most basic event service has four kinds of entities (supplier, consumer, eve nt, event service) and three basic functions (supply an event to the service, register interest in a kind of event, unregiste r nterest). Existing commercial event services do not provide event models that are much richer than this most basic service. For example, there are typically no constructs that en able operations over multiple entities. This paper describes high-level constructs (operating ove r multiple events, multiple consumers, etc.) provided by READY, an event notification system being developed at AT&T Labs [7]. Entities in the READY model include: consumer specifications that match over both single and compound event patterns; communication sessions that manage quality of service (QoS) and ordering properties for event delivery; grouping constructs for both specifications and s essions; event domains and boundary routers that bound the scope of event distribution and control the mapping of event s across domains. The result is a more powerful and flexible event service. The remainder of the paper is organized as follows. Section 2 offers an overview of related systems. In Section 3, we focus on client interactions with READY. Section 4 introduces READY event types. Section 5 describes specifications, which control the actions performed by READY servers due to supplied events. Section 6 describes constructs for managing boundaries between event domains. Finally, Section 7 discusses the current status of READY as well as some general issues raised by our work. We are in the process of completing an initial implementation of READY. At the same time we are exploring the merits of READY's high-level constructs by using READY as a core component of a unified messaging system [2]. Some of the examples presented here are taken from that domain.
{"title":"High-level constructs in the READY event notification system","authors":"R. Gruber, B. Krishnamurthy, E. Panagos","doi":"10.1145/319195.319225","DOIUrl":"https://doi.org/10.1145/319195.319225","url":null,"abstract":"There is growing interest in the use of general-purpose even t notification services as “middleware” for gluing together independently-developed distributed applications. This approach was first discussed by Oki et.al.in 1993 [14], where an early version of the (now) TIBCO Information Bus [20] was described. Since then, many other commercial products have been developed that accept events from event suppliers (publishers) and deliver them to event consumers (subscribers). Publish-subscribe mechanisms have also been retro-fitted to existing middleware products, including pe rsistent message queue products and TP monitors. There is also standards work in this area, including the CORBA Event Service [15] and more recently the CORBA Notification Service [16], a feature-enriched version of the Event Service. Despite all of these products and the standardization efforts, and despite the fact that event-driven computation i s not a new idea, there has been relatively little work on highlevel constructs for event services. The most basic event service has four kinds of entities (supplier, consumer, eve nt, event service) and three basic functions (supply an event to the service, register interest in a kind of event, unregiste r nterest). Existing commercial event services do not provide event models that are much richer than this most basic service. For example, there are typically no constructs that en able operations over multiple entities. This paper describes high-level constructs (operating ove r multiple events, multiple consumers, etc.) provided by READY, an event notification system being developed at AT&T Labs [7]. Entities in the READY model include: consumer specifications that match over both single and compound event patterns; communication sessions that manage quality of service (QoS) and ordering properties for event delivery; grouping constructs for both specifications and s essions; event domains and boundary routers that bound the scope of event distribution and control the mapping of event s across domains. The result is a more powerful and flexible event service. The remainder of the paper is organized as follows. Section 2 offers an overview of related systems. In Section 3, we focus on client interactions with READY. Section 4 introduces READY event types. Section 5 describes specifications, which control the actions performed by READY servers due to supplied events. Section 6 describes constructs for managing boundaries between event domains. Finally, Section 7 discusses the current status of READY as well as some general issues raised by our work. We are in the process of completing an initial implementation of READY. At the same time we are exploring the merits of READY's high-level constructs by using READY as a core component of a unified messaging system [2]. Some of the examples presented here are taken from that domain.","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"50 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116497883","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}
We have designed a fault-tolerant application composition and execution environment for distributed applications whose executions could span arbitrarily large durations. A preliminary version of the system has been implemented (both in C++ and Java) using distributed object and CORBA middleware technologies. In effect, we have implemented a transactional workfIow system that enables sets of inter-related tasks to be carried out and supervised in a dependable manner. Our system has been designed to meet the requirements of interoperabiIity, scalability, flexible task composition, dependability, dynamic reconfiguration and auditability.
{"title":"A transactional workflow based distributed application composition and execution environment","authors":"S. Shrivastava, S. Wheater","doi":"10.1145/319195.319207","DOIUrl":"https://doi.org/10.1145/319195.319207","url":null,"abstract":"We have designed a fault-tolerant application composition and execution environment for distributed applications whose executions could span arbitrarily large durations. A preliminary version of the system has been implemented (both in C++ and Java) using distributed object and CORBA middleware technologies. In effect, we have implemented a transactional workfIow system that enables sets of inter-related tasks to be carried out and supervised in a dependable manner. Our system has been designed to meet the requirements of interoperabiIity, scalability, flexible task composition, dependability, dynamic reconfiguration and auditability.","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"12 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133212799","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}
1 Challenge Historically, applications have been distributed in order to access more resources than a lone machine could supply, such as CPU power, disks, or the computers themselves (for fault tolerance). We are increasingly seeing applications which are distributed because they are meant to be used by multiple people, and multiple people generally have multiple machines. These applications are distributed by definition. A good example of this is a distributed multimedia application such as multicast video, email, or the World Wide Web. It is well understood how the interaction of software with people.makes the software more complicated; we are entering the realm of software which exists purely to glue people together. The popular focus on multimedia is on video and audio applications. While these certainly challenge current computers and profit companies, they are merely a shadow of the possibilities. This potential is not the ability of a computer to display one medium, but the ability to gracefully and efficiently handle a wide variety of data flows with differing requirements, many of which did not exist when that computer or its operating system was designed. The variation of types and topology of such flows is limited only by the creativity and whims of the human users. What sort of information flows will computers serve to us? What kinds of hardware and software will these machines need and have? How will these systems interact? We do not know. Nobody does. And we have to design our software to face this environment. This is the challenge of multimedia, and it parallels the general challenges facing these diffusely distributed applications in the near future. The important issue is not that software needs to be flexible and easily reconfigurable. We need to be able to control, predict, and modify the behavior of our software, and this requires that we have a firm understanding of and control over how software is configurable. We should not strive to make endlessly extendable systems-rather we should strive to make systems which are exactly as extendable as required. It is in this context that we are designing the Scout[6] system. Software designers have always been challenged to keep pace with the increasing demands placed on computers. Software, once written, is released into a dynamic world. Therefore, a fundamental property of successful software is that it can be changed. Most of the attention to this has been placed on static changes …
{"title":"Controllled flexibility in system design","authors":"Allen Brady Montz, L. Peterson","doi":"10.1145/319195.319233","DOIUrl":"https://doi.org/10.1145/319195.319233","url":null,"abstract":"1 Challenge Historically, applications have been distributed in order to access more resources than a lone machine could supply, such as CPU power, disks, or the computers themselves (for fault tolerance). We are increasingly seeing applications which are distributed because they are meant to be used by multiple people, and multiple people generally have multiple machines. These applications are distributed by definition. A good example of this is a distributed multimedia application such as multicast video, email, or the World Wide Web. It is well understood how the interaction of software with people.makes the software more complicated; we are entering the realm of software which exists purely to glue people together. The popular focus on multimedia is on video and audio applications. While these certainly challenge current computers and profit companies, they are merely a shadow of the possibilities. This potential is not the ability of a computer to display one medium, but the ability to gracefully and efficiently handle a wide variety of data flows with differing requirements, many of which did not exist when that computer or its operating system was designed. The variation of types and topology of such flows is limited only by the creativity and whims of the human users. What sort of information flows will computers serve to us? What kinds of hardware and software will these machines need and have? How will these systems interact? We do not know. Nobody does. And we have to design our software to face this environment. This is the challenge of multimedia, and it parallels the general challenges facing these diffusely distributed applications in the near future. The important issue is not that software needs to be flexible and easily reconfigurable. We need to be able to control, predict, and modify the behavior of our software, and this requires that we have a firm understanding of and control over how software is configurable. We should not strive to make endlessly extendable systems-rather we should strive to make systems which are exactly as extendable as required. It is in this context that we are designing the Scout[6] system. Software designers have always been challenged to keep pace with the increasing demands placed on computers. Software, once written, is released into a dynamic world. Therefore, a fundamental property of successful software is that it can be changed. Most of the attention to this has been placed on static changes …","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"158 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133650931","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}
Companies cooperating in the framework of a virtual enterprise have increasing demands for systems on which to base applications for their particular environment: groups of workers on distant independent LANs. In this paper, we present a transactional file system for a distributed persistent store designed to support cooperative engineering applications. The system integrates techniques, such as optimistic consistency protocols and versioning, tailored to provide efficient sharing of data, between users (at LAN scale) and between companies (at WAN scale).
{"title":"The PerDiS FS: a transactional file system for a distributed persistent store","authors":"J. Garcia, P. Ferreira, P. Guedes","doi":"10.1145/319195.319224","DOIUrl":"https://doi.org/10.1145/319195.319224","url":null,"abstract":"Companies cooperating in the framework of a virtual enterprise have increasing demands for systems on which to base applications for their particular environment: groups of workers on distant independent LANs. In this paper, we present a transactional file system for a distributed persistent store designed to support cooperative engineering applications. The system integrates techniques, such as optimistic consistency protocols and versioning, tailored to provide efficient sharing of data, between users (at LAN scale) and between companies (at WAN scale).","PeriodicalId":335784,"journal":{"name":"Proceedings of the 8th ACM SIGOPS European workshop on Support for composing distributed applications","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1998-09-07","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129745693","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
扫码关注我们
求助内容：
应助结果提醒方式：