The Experts below are selected from a list of 13179 Experts worldwide ranked by ideXlab platform

Harald Vogt - One of the best experts on this subject based on the ideXlab platform.

Marco Mauri - One of the best experts on this subject based on the ideXlab platform.

  • scene a service composition execution environment supporting dynamic changes disciplined through rules
    Lecture Notes in Computer Science, 2006
    Co-Authors: Massimiliano Colombo, Elisabetta Di Nitto, Marco Mauri
    Abstract:

    Service compositions are created by exploiting existing component services that are, in general, out of the control of the composition developer. The challenge nowadays is to make such compositions able to dynamically reconfigure themselves in order to address the cases when the component services do not behave as expected and when the execution context changes. We argue that the problem has to be tackled at two levels: on the one side, the Runtime Platform should be flexible enough to support the selection of alternative services, the negotiation of their service level agreements, and the partial replanning of a composition. On the other side, the language used to develop the composition should support the designer in defining the constraints and conditions that regulate selection, negotiation, and replanning actions at Runtime. In this paper we present the SCENE Platform that partially addresses the above issues by offering a language for composition design that extends the standard BPEL language with rules used to guide the execution of binding and re-binding self-reconfiguration operations.

  • ICSOC - SCENE: a service composition execution environment supporting dynamic changes disciplined through rules
    Service-Oriented Computing – ICSOC 2007, 2006
    Co-Authors: Massimiliano Colombo, Elisabetta Di Nitto, Marco Mauri
    Abstract:

    Service compositions are created by exploiting existing component services that are, in general, out of the control of the composition developer. The challenge nowadays is to make such compositions able to dynamically reconfigure themselves in order to address the cases when the component services do not behave as expected and when the execution context changes. We argue that the problem has to be tackled at two levels: on the one side, the Runtime Platform should be flexible enough to support the selection of alternative services, the negotiation of their service level agreements, and the partial replanning of a composition. On the other side, the language used to develop the composition should support the designer in defining the constraints and conditions that regulate selection, negotiation, and replanning actions at Runtime. In this paper we present the SCENE Platform that partially addresses the above issues by offering a language for composition design that extends the standard BPEL language with rules used to guide the execution of binding and re-binding self-reconfiguration operations.

Elisabetta Di Nitto - One of the best experts on this subject based on the ideXlab platform.

  • scene a service composition execution environment supporting dynamic changes disciplined through rules
    Lecture Notes in Computer Science, 2006
    Co-Authors: Massimiliano Colombo, Elisabetta Di Nitto, Marco Mauri
    Abstract:

    Service compositions are created by exploiting existing component services that are, in general, out of the control of the composition developer. The challenge nowadays is to make such compositions able to dynamically reconfigure themselves in order to address the cases when the component services do not behave as expected and when the execution context changes. We argue that the problem has to be tackled at two levels: on the one side, the Runtime Platform should be flexible enough to support the selection of alternative services, the negotiation of their service level agreements, and the partial replanning of a composition. On the other side, the language used to develop the composition should support the designer in defining the constraints and conditions that regulate selection, negotiation, and replanning actions at Runtime. In this paper we present the SCENE Platform that partially addresses the above issues by offering a language for composition design that extends the standard BPEL language with rules used to guide the execution of binding and re-binding self-reconfiguration operations.

  • ICSOC - SCENE: a service composition execution environment supporting dynamic changes disciplined through rules
    Service-Oriented Computing – ICSOC 2007, 2006
    Co-Authors: Massimiliano Colombo, Elisabetta Di Nitto, Marco Mauri
    Abstract:

    Service compositions are created by exploiting existing component services that are, in general, out of the control of the composition developer. The challenge nowadays is to make such compositions able to dynamically reconfigure themselves in order to address the cases when the component services do not behave as expected and when the execution context changes. We argue that the problem has to be tackled at two levels: on the one side, the Runtime Platform should be flexible enough to support the selection of alternative services, the negotiation of their service level agreements, and the partial replanning of a composition. On the other side, the language used to develop the composition should support the designer in defining the constraints and conditions that regulate selection, negotiation, and replanning actions at Runtime. In this paper we present the SCENE Platform that partially addresses the above issues by offering a language for composition design that extends the standard BPEL language with rules used to guide the execution of binding and re-binding self-reconfiguration operations.

  • SAC - Using agents for multi-target search on the Web
    Proceedings of the 2003 ACM symposium on Applied computing - SAC '03, 2003
    Co-Authors: Elisabetta Di Nitto, Carlo Ghezzi, Paolo Selvini
    Abstract:

    In this paper we present an approach to support multi-target search over a set of web nodes. Multi-target search allows users to specify multiple interdependent search objectives. Such objectives are then fulfilled by transparently contacting multiple information sources. We present a Runtime Platform and a language supporting extraction and assembly of information according to users' needs. The language is based on a XML query language and adapts it to the case where information is obtained by aggregating parts distributed over multiple sites. The Platform is based on mobile agents and acts as an intermediary between users and information providers.

  • CIA - Using Agents in Performing Multi-site Queries
    Cooperative Information Agents V, 2001
    Co-Authors: Elisabetta Di Nitto, Carlo Ghezzi, Maurizio Sabba, Paolo Selvini
    Abstract:

    In this paper we present a Runtime Platform and a language supporting infomediaries (information intermediaries) in tailoring information extracted from the web to satisfy end user requirements. The language is based on a XML query language and adapts it to the case where information is obtained by aggregating parts distributed over multiple sites. The Platform is based on mobile agents and acts as an intermediary between users and information providers.

Joachim Posegga - One of the best experts on this subject based on the ideXlab platform.

James M Stichnoth - One of the best experts on this subject based on the ideXlab platform.

  • the open Runtime Platform a flexible high performance managed Runtime environment
    Concurrency and Computation: Practice and Experience, 2005
    Co-Authors: Michal Cierniak, Brian T Lewis, Marsha Eng, Neal Glew, James M Stichnoth
    Abstract:

    The Open Runtime Platform (ORP) is a high-performance managed Runtime environment (MRTE) that features exact generational garbage collection, fast thread synchronization, and multiple coexisting just-in-time compilers (JITs). ORP was designed for flexibility in order to support experiments in dynamic compilation, garbage collection, synchronization, and other technologies. It can be built to run either Java or Common Language Infrastructure (CLI) applications, to run under the Windows or Linux operating systems, and to run on the IA-32 or Itanium processor family (IPF) architectures. Achieving high performance in a MRTE presents many challenges, particularly when flexibility is a major goal. First, to enable the use of different garbage collectors and JITs, each component must be isolated from the rest of the environment through a well-defined software interface. Without careful attention, this isolation could easily harm performance. Second, MRTEs have correctness and safety requirements that traditional languages such as C++ lack. These requirements, including null pointer checks, array bounds checks, and type checks, impose additional Runtime overhead. Finally, the dynamic nature of MRTEs makes some traditional compiler optimizations, such as devirtualization of method calls, more difficult to implement or more limited in applicability. To get full performance, JITs and the core virtual machine (VM) must cooperate to reduce or eliminate (where possible) these MRTE-specific overheads. In this paper, we describe the structure of ORP in detail, paying particular attention to how it supports flexibility while preserving high performance. We describe the interfaces between the garbage collector, the JIT, and the core VM; how these interfaces enable multiple garbage collectors and JITs without sacrificing performance; and how they allow the JIT and the core VM to reduce or eliminate MRTE-specific performance issues. Copyright © 2005 John Wiley & Sons, Ltd.

  • The Open Runtime Platform: a flexible high-performance managed Runtime environment: Research Articles
    Concurrency and Computation: Practice and Experience, 2005
    Co-Authors: Michal Cierniak, Brian T Lewis, Marsha Eng, Neal Glew, James M Stichnoth
    Abstract:

    The Open Runtime Platform (ORP) is a high-performance managed Runtime environment (MRTE) that features exact generational garbage collection, fast thread synchronization, and multiple coexisting just-in-time compilers (JITs). ORP was designed for flexibility in order to support experiments in dynamic compilation, garbage collection, synchronization, and other technologies. It can be built to run either Java or Common Language Infrastructure (CLI) applications, to run under the Windows or Linux operating systems, and to run on the IA-32 or Itanium processor family (IPF) architectures. Achieving high performance in a MRTE presents many challenges, particularly when flexibility is a major goal. First, to enable the use of different garbage collectors and JITs, each component must be isolated from the rest of the environment through a well-defined software interface. Without careful attention, this isolation could easily harm performance. Second, MRTEs have correctness and safety requirements that traditional languages such as C++ lack. These requirements, including null pointer checks, array bounds checks, and type checks, impose additional Runtime overhead. Finally, the dynamic nature of MRTEs makes some traditional compiler optimizations, such as devirtualization of method calls, more difficult to implement or more limited in applicability. To get full performance, JITs and the core virtual machine (VM) must cooperate to reduce or eliminate (where possible) these MRTE-specific overheads. In this paper, we describe the structure of ORP in detail, paying particular attention to how it supports flexibility while preserving high performance. We describe the interfaces between the garbage collector, the JIT, and the core VM; how these interfaces enable multiple garbage collectors and JITs without sacrificing performance; and how they allow the JIT and the core VM to reduce or eliminate MRTE-specific performance issues. Copyright © 2005 John Wiley & Sons, Ltd.An earlier version of this paper was published online [1].

  • The Open Runtime Platform: a flexible high‐performance managed Runtime environment
    Concurrency and Computation: Practice and Experience, 2005
    Co-Authors: Michal Cierniak, Brian T Lewis, Marsha Eng, Neal Glew, James M Stichnoth
    Abstract:

    The Open Runtime Platform (ORP) is a high-performance managed Runtime environment (MRTE) that features exact generational garbage collection, fast thread synchronization, and multiple coexisting just-in-time compilers (JITs). ORP was designed for flexibility in order to support experiments in dynamic compilation, garbage collection, synchronization, and other technologies. It can be built to run either Java or Common Language Infrastructure (CLI) applications, to run under the Windows or Linux operating systems, and to run on the IA-32 or Itanium processor family (IPF) architectures. Achieving high performance in a MRTE presents many challenges, particularly when flexibility is a major goal. First, to enable the use of different garbage collectors and JITs, each component must be isolated from the rest of the environment through a well-defined software interface. Without careful attention, this isolation could easily harm performance. Second, MRTEs have correctness and safety requirements that traditional languages such as C++ lack. These requirements, including null pointer checks, array bounds checks, and type checks, impose additional Runtime overhead. Finally, the dynamic nature of MRTEs makes some traditional compiler optimizations, such as devirtualization of method calls, more difficult to implement or more limited in applicability. To get full performance, JITs and the core virtual machine (VM) must cooperate to reduce or eliminate (where possible) these MRTE-specific overheads. In this paper, we describe the structure of ORP in detail, paying particular attention to how it supports flexibility while preserving high performance. We describe the interfaces between the garbage collector, the JIT, and the core VM; how these interfaces enable multiple garbage collectors and JITs without sacrificing performance; and how they allow the JIT and the core VM to reduce or eliminate MRTE-specific performance issues. Copyright © 2005 John Wiley & Sons, Ltd.

  • open Runtime Platform flexibility with performance using interfaces
    Proceedings of the 2002 joint ACM-ISCOPE conference on Java Grande, 2002
    Co-Authors: Michal Cierniak, Brian T Lewis, James M Stichnoth
    Abstract:

    According to conventional wisdom, interfaces provide flexibility at the cost of performance. Most high-performance Java virtual machines today tightly integrate their core virtual machines with their just-in-time compilers and garbage collectors to get the best performance. The Open Runtime Platform (ORP) is unusual in that it reconciles high performance with the extensive use of well-defined interfaces between its components. ORP was developed to support experiments in dynamic compilation, garbage collection, synchronization, and other technologies. To achieve this, two key interfaces were designed: one for garbage collection and another for just-in-time compilation. This paper describes some interesting features of these interfaces and discusses lessons learned in their use. One lesson we learned was to selectively expose small but frequently accessed data structures in our interfaces; this improves performance while minimizing the number of interface crossings.

  • Java Grande - Open Runtime Platform: flexibility with performance using interfaces
    Proceedings of the 2002 joint ACM-ISCOPE conference on Java Grande - JGI '02, 2002
    Co-Authors: Michal Cierniak, Brian T Lewis, James M Stichnoth
    Abstract:

    According to conventional wisdom, interfaces provide flexibility at the cost of performance. Most high-performance Java virtual machines today tightly integrate their core virtual machines with their just-in-time compilers and garbage collectors to get the best performance. The Open Runtime Platform (ORP) is unusual in that it reconciles high performance with the extensive use of well-defined interfaces between its components. ORP was developed to support experiments in dynamic compilation, garbage collection, synchronization, and other technologies. To achieve this, two key interfaces were designed: one for garbage collection and another for just-in-time compilation. This paper describes some interesting features of these interfaces and discusses lessons learned in their use. One lesson we learned was to selectively expose small but frequently accessed data structures in our interfaces; this improves performance while minimizing the number of interface crossings.