Extending software component models with the master–worker paradigm

Component-based Development (CBD) is an important emerging topic in Software Engineering, promising long sought after benefits like increased reuse and reduced time-to-market (and hence software production cost). However, there are at present many obstacles to overcome before CBD can succeed. For one thing, CBD success is predicated on a standardised market place for software components, which does not yet exist. In fact currently CBD even lacks a universally accepted terminology. Existing component models adopt different component definitions and composition operators. Therefore much research remains to be done. We believe that the starting point for this endeavour should be a thorough study of current component models, identifying their key characteristics and comparing their strengths and weaknesses. A desirable side-effect would be clarifying and unifying the CBD terminology. In this tutorial, we present a clear and concise exposition of all the current major software component models, including a taxonomy. The purpose is to distill and present knowledge of current software component models, as well as to present an analysis of their properties with respect to commonly accepted criteria for CBD. The taxonomy also provides a starting point for a unified terminology.

Modern software development is based on a systems approach, in which a program or software complex is considered as a system of interacting software components. Models of software components are analogs of complex system subsystems. Therefore, a complex program is considered as a system of software components. The organization of the structure of software components affects the quality and result of the program. The organization of interaction between software components affects the efficiency of the program. An important factor in the system of software components is the life cycle, which determines the effectiveness and feasibility of using this program. Software differs from many complex systems and information systems in that it has the ability to increase its life cycle. Moreover, the need to increase the life cycle is characterized by two factors: external and internal. The internal factor arises due to the obsolescence of the program. In this case, it does not meet the new conditions, for example, a new operating system. The external factor arises from external influences in the form of interference or purposeful actions, such as computer viruses. The problem of creating the structure of software components of computing systems and information systems that ensure the duration of the life cycle in the presence of external influences is topical. The study of this problem contributes to the improvement of the technological base of computing systems and information systems that solve applied problems. The article presents a new life cycle model based on two models of growth and degradation. The article recommends a resource-based approach for life cycle assessment. As an analytical solution, it is proposed to use a logistic equation, which describes the mechanisms of the life cycle formation process quite well. The article discusses three types of resource in calculations: physical, technological and communicative. A general redundancy solution is proposed to create a network with the inclusion of a multigraph model.

Component-based software development established as an effective technique to cope with the increasing complexity of modern computing systems. In the context of real-time systems, the M-BROE framework has been recently proposed to efficiently support component-based development of real-time applications on multiprocessor platforms in the presence of shared resources. The framework relies on a two-stage approach where software components are first partitioned upon a virtual multiprocessor platform and are later integrated upon the physical platform by means of component interfaces that abstract from the internal details of the applications. This work presents a complete design flow for the M-BROE framework. Starting from a model of software components, a first method is proposed to partition applications to virtual processors and perform a synthesis of multiple component interfaces. Then, a second method is proposed to support the integration of the components by allocating virtual processors to physical processors. Both methods take resource sharing into account. Experimental results are also presented to evaluate the proposed methodology.

Computer architecture is now at an important juncture as single-core CPU power is expected to be nearly constant. The microprocessor industry is rapidly moving towards chip multi-processors (CMPs), commonly referred to as multi-core processors. The transition of CPUs from single to multi-core implementations requires a corresponding shift in the programming paradigm for grid and e-science libraries. Naive implementations of processing on multi-core systems can severely impact performance because of limitations of shared bus bandwidth, cache size and coherency, and communication between threads. To optimize the performance of e-science services, careful application of thread-level parallelism is needed. We study this problem in the context of processing XML data used in grid and e-science applications. The web services model, which strongly leverages XML, has been adopted as the basic architecture for grid and e-science services. As a result, the optimization of separate Web services applications is critical because Web services that are deployed in a longer chain of service processing events must guarantee minimal response times to ensure overall system performance. Our goal is to analyze and provide insightful feedback on cache behavior of each core and reveal performance limitations, bottlenecks, and multi-threaded optimization opportunities for processing XML data relevant to grid and e-science application data formats. We use a micro-architectural emulation framework, Multi-core Grid (McGrid), to generate performance data at various levels of granularity. We analyze cache behavior to quantify the exact gains and present recommendations for processing XML data in grid and e-science applications that will be deployed on emerging multi-core systems.

A Distributed Run-Time Environment for the Kalray MPPA®-256 Integrated Manycore Processor

Abstract: The fast growth of high-bandwidth wide-area networks has encouraged the development of computational grids. To deal with the increasing complexity of grid applications, the software component technology seems very appealing since it emphasizes software composition and re-use. However, current software component models only support explicit data transfers between components through remote procedure call (RPC), remote method invocation (RMI) or event based ports. The distributed shared memory paradigm has demonstrated its utility by enabling a transparent access to data via a globally shared data space. Data localization, replication and transfer as well as synchronization of concurrent accesses are delegated to an external data-sharing service. This paper proposes to extend software component models with shared memory capabilities: a) a transparent access to shared data, and b) the possibility to use shared data as parameters of operations provided by component ports. The proposed model is instantiated as an extension of the CORBA Component Model (CCM) and the Common Component Architecture (CCA), using the transparent data access model provided by the JUXMEM grid data-sharing service. Key-words: data sharing, component, grid, JUXMEM

The software development trend by selecting and assembling commercial off-the shelf (COTS) components is widely accepted. This approach implies that the selected components must not only match application requirements but also work well with each other. These component selection and integration issues are not much addressed in research and commercial world as there is no standardized way to specify component descriptions that will be used for selection and integration of components. This research proposes a metadata model for reusable software components that can be used by component vendors to describe components to be published and by system integrators to specify search criteria for required components. A prototype of the model has been devleoped to employ the proposed metadata description which comprises integration-related attributes, all of which can be used to determine the degree of compatibility between integrated components. With this prototype, specifications of required components are compared with specifications of published components, and the results are the candidate ensembles that match requirement specifications. These ensembles are then ranked by compatibility scores according to predefined integration rules. System integrators can make further decision on the ensemble that best suits their applications based on the results from the prototype. It is expected that this metadata model and its integration approach can be a starting point for a more standardized component specification and deployment in the future.

Computing potential is wasted and idle not only when applications are executed, but also when a user navigates the Internet. To take advantage of this, an architecture named Parasite has been designed in order to use distributed and networked resources, without disturbing local computation. This is the working principle of certain global computing projects, but our development introduces new ideas with respect to user intervention, the distributed programming paradigm or the resident software on each user's computer. The project is based on developing software technologies and infrastructures in order to facilitate Web-based distributed computing. This paper outlines the most recent advances in the project, as well as discussing the architecture developed and an experimental framework that would validate this infrastructure.

We combine model learning and model checking in a challenging case study involving Linux, Windows and FreeBSD implementations of TCP. We use model learning to infer models of different software components and then apply model checking to fully explore what may happen when these components (e.g. a Linux client and a Windows server) interact. Our analysis reveals several instances in which TCP implementations do not conform to their RFC specifications.

Computing effective properties of random heterogeneous materials on heterogeneous parallel processors

Composite distributed services involve local and remote services that get orchestrated according to specific business logic. This logic can be programmed by applying a traditional general-purpose programming language, but is generally described using a workflow language that coordinates a set of given services. The services involved in the composition, or the composition may need to evolve both at the business logic level (workflow level) and the global architecture level. This paper presents a solution to ease such evolution for compound distributed services and the authors’ proposal enables the evolution of both the business logic and the underlying architecture. This paper suggests relying on a distributed software component model to represent and easily manage the set of local or remote software entities (services) involved in the composition. Composite services are represented in a model that combines the use of a distributed and hierarchical software component model and new timed-automata based workflow language. This combination makes explicit the separation between functional and non-functional concerns, and as a consequence this approach helps in defining the required and various evolution procedures in context to compound services.

Model learning is a black-box technique for constructing state machine models of software and hardware components, which has been successfully used in areas such as telecommunication, banking cards, network protocols, and control software. The underlying theoretic framework (active automata learning) was first introduced in a landmark paper by Dana Angluin in 1987 for finite state machines. In order to make model learning more widely applicable, it must be further developed to scale better to large models and to generate richer classes of models. Recently, various techniques have been employed to extend automata learning to extended automata models, which combine control flow with guards and assignments to data variables. Such techniques infer guards over data parameters and assignments from observations of test output. In the black-box model of active automata learning this can be costly and require many tests, while in many application scenarios source code is available for analysis. In this paper, we explore some directions for future research on how black-box model learning can be enhanced using white-box information extraction methods, with the aim to maintain the benefits of dynamic black-box methods while making effective use of information that can be obtained through white-box techniques.

This chapter introduces a programming environment for SCI clusters that takes advantage of both parallel and distributed programming paradigms. It aims at helping programmers to design high performance applications based on the assembling of generic software components. This environment is based on CORBA (Common Object Request Broker Architecture), with our own extensions to support parallelism across several cluster nodes within a distributed system. Our contribution concerns extensions to support a new kind of object, which we call a parallel CORBA object (or parallel object), as well as the integration of message-passing paradigms, mainly MPI, within a parallel object. These extensions exploit as much as possible the functionality offered by CORBA and require few modifications to an available CORBA implementation. This paper reports on these extensions and the description of a runtime system, called Cobra, which provides resource allocation services for the execution of parallel objects.

eScience applications need to use distributed Grid environments where each component is an individual or cluster of multicore machines. These are expected to have 64-128 cores 5 years from now and need to support scalable parallelism. Users will want to compose heterogeneous components into single jobs and run seamlessly in both distributed fashion and on a future "Grid on a chip" with different subsets of cores supporting individual components. We support this with a simple programming model made up of two layers supporting traditional parallel and Grid programming paradigms (workflow) respectively. We examine for a parallel clustering application, the Concurrency and Coordination Runtime CCR from Microsoft as a multi-paradigm runtime that integrates the two layers. Our work uses managed code (C#) and for AMD and Intel processors shows around a factor of 5 better performance than Java. CCR has MPI pattern and dynamic threading latencies of a few microseconds that are competitive with the performance of standard MPI for C.

The microprocessor industry is rapidly moving towards chip multi-processors (CMPs), commonly referred to as multi-core processors, where multiple cores can independently execute different threads. This change in computer architecture requires corresponding design modifications in programming paradigms, including grid middleware tools, to harness the opportunities presented by multi-core processors. Naive implementations of grid middleware on multi-core systems can severely impact performance because of limitations of shared bus bandwidth, cache size and coherency, and communication between threads. The goal of developing an optimized multi-threaded grid middleware for emerging multi-core processors will be realized only if researchers and developers have access to an in-depth analysis of the impact of several low level microarchitectural parameters on performance. None of the current grid simulators and emulators provide feedback at the microarchitectural level, which is essential for such an analysis. We describe the initial design and implementation of an emulation framework, Multi-core Grid (McGrid), to analyze and provide insightful feedback on the performance limitations, bottlenecks, and optimization opportunities for grid middleware on multi-core systems. We describe early performance results of emulating the processing of some representative XML based grid documents on multi-core nodes using the McGrid framework.