Search

With an growing number of web services available on the Internet, an increasing burden is imposed on the use and management of service repository. Service clustering has been employed to facilitate a wide range of service-oriented tasks, such as service discovery, selection, composition and recommendation. Conventional approaches have been proposed to cluster web services by using explicit features, including syntactic features contained in service descriptions or semantic features extracted by probabilistic topic models. However, service implicit features are ignored and have yet to be properly explored and leveraged. To this end, we propose a novel heuristics-based framework DeepWSC for web service clustering. It integrates deep semantic features extracted from service descriptions by an improved recurrent convolutional neural network and service composability features obtained from service invocation relationships by a signed graph convolutional network, to jointly generate integrated implicit features for web service clustering. Extensive experiments are conducted on 8,459 real-world web services. The experiment results demonstrate that DeepWSC outperforms state-of-the-art approaches for web service clustering in terms of multiple evaluation metrics.

Differential Privacy (DP) formalizes privacy in mathematical terms and provides a robust concept for privacy protection. DIfferentially Private Data Synthesis (DIPS) techniques produce and release synthetic individual-level data in the DP framework. One key challenge to develop DIPS methods is the preservation of the statistical utility of synthetic data, especially in high-dimensional settings. We propose a new DIPS approach, STatistical Election to Partition Sequentially (STEPS) that partitions data by attributes according to their importance ranks according to either a practical or statistical importance measure. STEPS aims to achieve better original information preservation for the attributes with higher importance ranks and produce thus more useful synthetic data overall. We present an algorithm to implement the STEPS procedure and employ the privacy budget composability to ensure the overall privacy cost is controlled at the pre-specified value. We apply the STEPS procedure to both simulated data and the 2000–2012 Current Population Survey youth voter data. The results suggest STEPS can better preserve the population-level information and the original information for some analyses compared to PrivBayes, a modified Uniform histogram approach, and the flat Laplace sanitizer.

In this work a platform-aware model-driven engineering process for building component-based embedded software systems using annotated analysis models is described. The process is supported by a framework, called MICOBS, that allows working with different component technologies and integrating different tools that, independently of the component technology, enable the analysis of non-functional properties based on the principles of composability and compositionality. An actor, called Framework Architect, is responsible for this integration. Three other actors take a relevant part in the analysis process. The Component Provider supplies the components, while the Component Tester is in charge of their validation. The latter also feeds MICOBS with the annotated analysis models that characterize the extra-functional properties of the components for the different platforms on which they can be deployed. The Application Architect uses these components to build new systems, performing the trade-off between different alternatives. At this stage, and in order to verify that the final system meets the extra-functional requirements, the Application Architect uses the reports generated by the integrated analysis tools. This process has been used to support the validation and verification of the on-board application software for the Instrument Control Unit of the Energetic Particle Detector of the Solar Orbiter mission.

The human immune system is studied at different scales (molecular, cellular, tissue, organism, population) with varied granularity and spatiotemporal dimensions. Innate and adaptive immune responses to viral infections are researched in vitro, in vivo, and in silico using mathematical and computational methods. The construction of computational models is an iterative and interactive process which combines existing knowledge and hypotheses (knowledge-driven approach) with empirical datasets (data-driven approach). The resulting models should ideally provide reusability, composability, and interoperability to support system simulation. The main premises of this paper are (1) computational models can be used not only for representation of existing knowledge, but also as experimental tools to demonstrate, exemplify, create, and serve as test-beds for the analysis of empirical data;and (2) computational models should be evaluated in terms of their usability (defined as a measure of how well a specified group of users can achieve predefined goals effectively, efficiently, and satisfactorily in a specified context of use). The usability measure is specified by the context information: user characteristics, their goals, and additional constraints (e.g., data availability, temporal limitations). This paper focuses on the modelling process performed by multidisciplinary teams and the usability of models for the exploration of immune response to viral infections. (c) 2021 The Authors. Published by Elsevier B.V. This is an open access article under the CC BY-NC-ND license (https://creativecommons.org/licenses/by-nc-nd/4.0) Peer-review under responsibility of the scientific committee of the Complex Adaptive Systems Conference, June 2021.

Component-based design has received considerable attention owing to its advantages in terms of security and safety when developing modern embedded systems. To effectively allocate computing resources to components in these systems, real-time component-based scheduling theory has been studied from various perspectives. The main advantage of component-based scheduling theory is that it guarantees the schedulability of an independent component and composability of multiple components. However, the existing component scheduling theory cannot be directly applied to real hardware platform due to an impractical assumption that resource allocation must be conducted across the continuum of real numbers, whereas actual operating systems (or virtualization systems) allocate resources in units of scheduling time quantum. In this study, we proposed a new efficient resource allocation and supply mechanism for quantumized hardware platforms while using real-number-based component interface. In simulation results with randomly-generated workloads, our approach reduced the overhead of existing approaches by up to 97.1% in an individual component. In composition of multiple components, our approach has up to 0.41 better acceptance ratio than existing approaches.

Community efforts in the computational molecular sciences (CMS) are evolving toward modular, open, and interoperable interfaces that work with existing community codes to provide more functionality and composability than could be achieved with a single program. The Quantum Chemistry Common Driver and Databases (QCDB) project provides such capability through an application programming interface (API) that facilitates interoperability across multiple quantum chemistry software packages. In tandem with the Molecular Sciences Software Institute and their Quantum Chemistry Archive ecosystem, the unique functionalities of several CMS programs are integrated, including CFOUR, GAMESS, NWChem, OpenMM, Psi4, Qcore, TeraChem, and Turbomole, to provide common computational functions, i.e., energy, gradient, and Hessian computations as well as molecular properties such as atomic charges and vibrational frequency analysis. Both standard users and power users benefit from adopting these APIs as they lower the language barrier of input styles and enable a standard layout of variables and data. These designs allow end-to-end interoperable programming of complex computations and provide best practices options by default.

This perspectives article addresses risk in cyber defense and identifies opportunities to incorporate risk analysis principles into the cybersecurity field. The Science of Security (SoS) initiative at the National Security Agency seeks to further and promote interdisciplinary research in cybersecurity. SoS organizes its research into the Five Hard Problems (5HP): (1) scalability and composability; (2) policy-governed secure collaboration; (3) security-metrics-driven evaluation, design, development, and deployment; (4) resilient architectures; and (5) understanding and accounting for human behavior. However, a vast majority of the research sponsored by SoS does not consider risk and when it does so, only implicitly. Therefore, we identify opportunities for risk analysis in each hard problem and propose approaches to address these objectives. Such collaborations between risk and cybersecurity researchers will enable growth and insight in both fields, as risk analysts may apply existing methodology in a new realm, while the cybersecurity community benefits from accepted practices for describing, quantifying, working with, and mitigating risk.

Simulation models are widely used to study complex systems. Current simulation models are generally handcrafted using expert knowledge (knowledge-driven); however, this process is slow and introduces modeler bias. This article presents an approach towards data-driven simulation modeling by developing a framework that discovers simulation models in an automated way for mobile agent-based applications. The framework is comprised of three components: (1) a model space specification, (2) a search method (genetic algorithm), and (3) framework measurement metrics. The model space specification provides a formal specification for the general model structure from which various models can be generated. The search method is used to efficiently search the model space for candidate models that exhibit desired behavior patterns. The five framework measurement metrics: flexibility, comprehensibility, controllability, composability, and robustness, are developed to evaluate the overall framework. The results demonstrate that it is possible to discover a variety of interesting models using the framework.

Background Delivering tools for genome analysis to users is often difficult given the complex dependencies and conflicts of such tools. Container virtualization systems (such as Singularity) isolate environments, thereby helping developers package tools. However, these systems lack mutual composability, i.e., an easy way to integrate multiple tools in different containers and/or on the host. Another issue is that one may be unable to use a single container system of the same version at all the sites being used, thus discouraging the use of container systems. Results We developed LPMX, an open-source pure rootless composable container system that provides composability; i.e., the system allows users to easily integrate tools from different containers or even from the host. LPMX accelerates science by letting researchers compose existing containers and containerize tools/pipelines that are difficult to package/containerize using Conda or Singularity, thereby saving researchers’ precious time. The technique used in LPMX allows LPMX to run purely in userspace without root privileges even during installation, thus ensuring that we can use LPMX at any Linux clusters with major distributions. The lowest overhead for launching containers with LPMX gives us courage to isolate tools as much as possible into small containers, thereby minimizing the chance of conflicts. The support for the layered file system keeps the total size of container images for a single genomic pipeline modest, as opposed to Singularity, which uses mostly a flat single-layer image. Conclusions LPMX is pure rootless container engine with mutual composability, thus saving researchers’ time, and accelerating science.

Proofs in simulation-based frameworks have the greatest rigor when they are machine checked. But the level of details in these proofs surpasses what the formal-methods community can handle with existing tools. Existing formal results consider streamlined versions of simulation-based frameworks to cope with this complexity. Hence, a central question is how to abstract details from composability results and enable their formal verification.In this paper, we focus on the modeling of system communication in composable security statements. Existing formal models consider fixed communication patterns to reduce the complexity of their proofs. However, as we will show, this can affect the reusability of security statements. We propose an abstract approach to modeling system communication in Constructive Cryptography that avoids this problem. Our approach is suitable for mechanized verification and we use CryptHOL, a framework for developing mechanized cryptography proofs, to implement it in the Isabelle/HOL theorem prover. As a case study, we formalize the construction of a secure channel using Diffie-Hellman key exchange and a one-time-pad.

Robotic testbeds used for flight and research technology development are highly complicated electromechanical systems demanding large engineering effort to configure and manage safety-critical hardware. The software that interoperates with robotic testbeds needs to be robust yet flexible to accommodate rapidly changing testbed needs and other operational demands in a cost-efficient manner. The Jet Propulsion Laboratory (JPL) presents a new open-source C++ library called Fastcat for powerful and flexible EtherCAT device configuration for testbed and robotic applications. Fastcat implements a set of C drivers called ‘Just SOEM Drivers’ built on the popular Simple Open EtherCAT Master library for a small, but highly tested set of supported EtherCAT devices. Fastcat offers a rich set of capabilities such as supporting an arbitrary number of EtherCAT Masters, a YAML input configuration file, and a visualization tool ‘Fcviz’ to graph the bus topology using the open-source Graphiz library. Furthermore, a novel feature called ‘Fastcat Signals’ can efficiently route data and commands between devices to compose self-contained closed loop control systems such as heaters or joint-torque controllers with zero added latency. Abstract device types like signal generators, functions, and PID controllers and offline versions of device hardware drivers allow for powerful composability, offline-only testing, and flexible hybrid partial online – offline bus topologies. The Fastcat core library is middleware agnostic, but ROS2 wrappers are developed for ease-of-use. This paper will describe design tradeoffs, an overview of the implementation of these capabilities, and early results from the first JPL Robotic testbed use.

Since the inception of Bitcoin, a plethora of distributed ledgers differing in design and purpose has been created. While by design, blockchains provide no means to securely communicate with external systems, numerous attempts towards trustless cross-chain communication have been proposed over the years. Today, cross-chain communication (CCC) plays a fundamental role in cryptocurrency exchanges, scalability efforts via sharding, extension of existing systems through sidechains, and bootstrapping of new blockchains. Unfortunately, existing proposals are designed ad-hoc for specific use-cases, making it hard to gain confidence in their correctness and composability. We provide the first systematic exposition of cross-chain communication protocols.

This publication is based on our paper presented at the IEEE International Conference on Software Architecture 2019. Due to their close interconnection with the outside world, cyber-physical systems are vulnerable to information leaks. Accordingly, it is crucial for software engineers to regulate and analyze the flow of information through systems. The microservice architectural style requires engineers to refine the regulations into security policies for the constituent software components. These policies must be composable to secure the information flow from end to end. However, since security is hard to compose, a composition of secure components may lead to an insecure system. In our paper, we enable microservice architectures of cyber-physical systems to be composed securely. First, we provide engineers with a set of architectural well-formedness rules for the refinement of security policies, ensuring composability if the constituent components communicate by message passing. Second, we present a verification technique to analyze whether the real-time message passing of components adheres to their refined security policies. Since the analysis results are securely composable, we assure engineers that a composition of secure components will always lead to a secure system. We evaluated the accuracy of our contributions using an extension of the CoCoME case study.

One of the benefits of decentralized finance (DeFi) – an alternative financial system built on blockchain – is composability, which means the system’s building blocks (tokens) can freely interact with one another to form new services. One example is stablecoin, a token with fixed exchange rate, which is backed by token collaterals. While stablecoins can be used to facilitate payments and exchanges, in DeFi they can be used to earn returns (“yield farming”), potentially multiplicatively. We use transaction-level blockchain data to analyze a stablecoin’s flows between protocols and provide suggestive evidence of DeFi yield-chasing behavior. We shed light on what DeFi total value locked might really measure and highlight the complexity in DeFi analysis and market surveillance.

To implement Service Oriented Architecture (SOA) in a banking company for transactional banking activity, this paper aims to overcome the problem of several related surrounding systems which has the same function in the different system by using Domain Driven Design. The paper proposes an approach to SOA using Web Services for service delivery in the area of transactional banking activities. Several systems will be connected to a BUS that will wait on and manage any request coming from other applications. To design the system then in this paper also will identify which application will consume the same function and analyze which function belongs to a certain domain. The paper finds that the implementation of an SOA system for transactional banking activities can be achieved by rapidly changing the habit of scaling up the system and application. This study shows that banking activity has a huge number of systems that should sync one and another to maintain the data integrity, availability, interoperability, and composability of the system.

Many-core platforms are rapidly expanding in various embedded areas as they provide the scalable computational power required to meet the ever-growing performance demands of embedded applications and systems. However, the huge design space of possible task mappings, the unpredictable workload dynamism, and the numerous non-functional requirements of applications in terms of timing, reliability, safety, and so forth. impose significant challenges when designing many-core systems. Hybrid Application Mapping (HAM) is an emerging class of design methodologies for many-core systems which address these challenges via an incremental (per-application) mapping scheme: The mapping process is divided into (i) a design-time Design Space Exploration (DSE) step per application to obtain a set of high-quality mapping options and (ii) a run-time system management step in which applications are launched dynamically (on demand) using the precomputed mappings. This paper provides an overview of HAM and the design methodologies developed in line with it. We introduce the basics of HAM and elaborate on the way it addresses the major challenges of application mapping in many-core systems. We provide an overview of the main challenges encountered when employing HAM and survey a collection of state-of-the-art techniques and methodologies proposed to address these challenges. We finally present an overview of open topics and challenges in HAM, provide a summary of emerging trends for addressing them particularly using machine learning, and outline possible future directions. While there exists a large body of HAM methodologies, the techniques studied in this paper are developed, to a large extent, within the scope of invasive computing. Invasive computing introduces resource awareness into applications and employs explicit resource reservation to enable incremental application mapping and dynamic system management., publishedVersion

International audience; Component-based software engineering is a paradigm that fosters software flexibility and emphasizes composability and reuse of software components. These are runtime units that provide services and, in turn, may require other services to operate. Assembling components consists in binding compo-nents' required services to provided ones to deliver composite services with added value. Building a composite service is a challenging task as it requires identifying components and services that are compatible, binding them to implement the service, and describe it for discovery. For that, the vocabulary used to describe component-based services (i.e., services offered by components or assemblies) must support the description of required services, and descriptions must be combinable in order to automatically generate composite service descriptions. However, existing solutions are limited to the description and composition of provided (and not required) services. In this paper, we consider ontologies to describe component-based services implemented by component assemblies. After comparing existing service ontologies, we present an extension of OWLS called Comp-O. Through a proof-of-concept, we demonstrate how the added semantics can be handled to automatically build composite service descriptions.

Microservices architecture has become one of the most prominent software architectures in the software development processes due to its features such as scalability, maintainability, resilience, and composability. It allows developing business applications in a decentralized manner by dividing the important business logic into separate independent services. Digital certificates are used to verify the identity of microservices in most cases. However, the certificate authorities (CA) who issue the certificates to microservices cannot be trusted always since they can issue certificates without the consent of the relevant microservice. Nevertheless, existing implementations of certificate transparency are mostly centralized and has the vulnerability of the single point of failure. The distributed ledger technologies such as blockchain can be used to achieve decentralized nature in certificate transparency implementations. A blockchain-based decentralized certificate transparency system specified for microservices architecture is proposed in this paper to ensure secure communication among services. After the implementation and deployment in a cloud service, the system expressed average certificate querying time of 643 milliseconds along with the highly secured service provided.

International audience; We propose a compositional specification theory for reason- ing about components that interact by synchronisation of input and out- put (I/O) actions, in which the specification of a component constrains the temporal ordering of interactions with the environment. Such a the- ory is motivated by the need to support composability of components, in addition to modelling environmental assumptions, and reasoning about run-time behaviour. Models can be specified operationally by means of I/O labelled transition systems augmented by an inconsistency predi- cate on states, or in a purely declarative manner by means of traces. We introduce a refinement preorder that supports safe-substitutivity of components. Our specification theory includes the operations of parallel composition for composing components at run-time, logical conjunction for independent development, and quotient for incremental development. We prove congruence properties of the operations and show correspon- dence between the operational and declarative frameworks.

Complex simulation systems often comprise multiple distributed simulators that need to interoperate and synchronize states and events. In many cases, the simulation logics which are developed by different teams with specific expertise, need to be integrated to build a complete simulation system. Thus, supporting composability and reusability of simulation functionalities with minimal integration and performance overhead is a challenging but required capability. Middleware for game engines are promising to realize both the modular and reusable development criteria as well as the high performance requirements, while data-centric publish/subscribe middleware can support seamless integration and synchronization of the distributed artifacts. However, differences in the level of abstraction at which these middleware operate and the semantic differences in their underlying ontologies make it hard and challenging for simulation application developers and system integrators to realize a complete, operational system. To that end this paper presents a model-driven approach to blending the two middleware, wherein the modeling capabilities provide intuitive and higher-level abstractions for developers to reason about the composition and validation of the complete system, and the generative capabilities address the inherent and accidental complexities incurred in reconciling the semantic differences between the gaming and pub/sub middleware. We present a concrete implementation of our approach and illustrate its use and performance results using simple use cases.

We propose an entanglement-based quantum bit string commitment protocol whose composability is proven in the random oracle model. This protocol has the additional property of preserving the privacy of the committed message. Even though this property is not resilient against man-in-the-middle attacks, this threat can be circumvented by considering that the parties communicate through an authenticated channel. The protocol remains secure (but not private) if we realize the random oracles as physical unclonable functions in the so-called bad PUF model with access before the opening phase., Comment: 8 pages, 4 figures

In this paper, a model-driven software collaborative modeling method is proposed, and a software collaborative modeling framework on model assembly and model updating is established. The composability of models, the integrity of model assembly and the consistency of model updating are studied from two aspects: model assembly mechanism and model updating mechanism. The collaborative modeling protocol is defined, and six collaborative relationship stereotypes are introduced to add collaborative semantics to the model based on the extensible mechanism of UML. The algorithm of model assembly and integrity checking is proposed and the collaborative modeling of multiple clients is implemented. The algorithm of model updating and consistency checking is proposed to solve the problem of model updating in collaborative modeling.

We propose a heuristics-based social-sensor cloud service selection and composition model to reconstruct mosaic scenes. The proposed approach leverages crowdsourced social media images to create an image mosaic to reconstruct a scene at a designated location and an interval of time. The novel approach relies on the set of features defined on the bases of the image metadata to determine the relevance and composability of services. Novel heuristics are developed to filter out non-relevant services. Multiple machine learning strategies are employed to produce smooth service composition resulting in a mosaic of relevant images indexed by geolocation and time. The preliminary analytical results prove the feasibility of the proposed composition model.

ALMARVI is a collaborative European research project funded by Artemis involving 16 industrial as well as academic partners across 4 countries, working together to address various computational challenges in image and video processing in 3 application domains: healthcare, surveillance and mobile. This paper is an editorial for a special issue discussing the integrated system created by the partners to serve as a cross-domain solution for the project. The paper also introduces the partner articles published in this special issue to discuss the various technological developments achieved within ALMARVI spanning all system layers, from hardware to applications. We illustrate the challenges faced within the project based on use cases from the three targeted application domains, and how these can address the 4 main project objectives addressing 4 challenges faced by high performance image and video processing systems: massive data rate, low power consumption, composability and robustness. We present a system stack composed of algorithms, design frameworks and platforms as a solution to these challenges. Finally, the use cases from the three different application domains are mapped on the system stack solution and are evaluated based on their performance for each of the 4 ALMARVI objectives.

When analyzing the round complexity of multi-party protocols, one often overlooks the fact that underlying resources, such as a broadcast channel, can by themselves be expensive to implement. For example, it is well known that it is impossible to implement a broadcast channel by a (deterministic) protocol in a sublinear (in the number of corrupted parties) number of rounds. The seminal works of Rabin and Ben-Or from the early 1980s demonstrated that limitations as the above can be overcome by using randomization and allowing parties to terminate at different rounds, igniting the study of protocols over point-to-point channels with probabilistic termination and expected constant round complexity. However, absent a rigorous simulation-based definition, the suggested protocols are proven secure in a property-based manner or via ad hoc simulation-based frameworks, therefore guaranteeing limited, if any, composability. In this work, we put forth the first simulation-based treatment of multi-party cryptographic protocols with probabilistic termination. We define secure multi-party computation (MPC) with probabilistic termination in the UC framework and prove a universal composition theorem for probabilistic termination protocols. Our theorem allows to compile a protocol using deterministic termination hybrids into a protocol that uses expected constant round protocols for emulating these hybrids, preserving the expected round complexity of the calling protocol. We showcase our definitions and compiler by providing the first composable protocols (with simulation-based security proofs) for the following primitives, relying on point-to-point channels: (1) expected constant round perfect Byzantine agreement, (2) expected constant round perfect parallel broadcast, and (3) perfectly secure MPC with round complexity independent of the number of parties.

Current simulation models are not only represented in the form of traditional data or formula for pure theory analysis but expanded to be simulation modeling assets that are featured with complicated structure, diverse behaviors, and abundant semantics. Semantic composability, therefore, receives a constantly growing attention in recent years. So far, one of the popular solutions to enhance semantic expressiveness is domain specific modeling based on general metamodeling (GMM) facilities. But for some particular domains, researchers identified the need of deeper semantic expressiveness therefore proposed domain specific metamodeling (DSMM). Hence, this paper aims to explore the underlying methodologies of DSMM for supporting deep semantic composability. Compared with several usual alternatives based on GMM, this paper applies the multi-level metamodeling architecture to create a set of metamodeling primitives using an example named SEvent. In fact, SEvent is a novel formalism that slightly extends Petri net to support continuous states transition and continuous event triggering. As a proof of concept, we concentrate on developing the textual syntax of SEvent and using it to represent torpedo’s behaviors.

Combat system effectiveness simulation (CSES) is a special type of complex system simulation. Three non-functional requirements (NFRs), i.e. model composability, domain specific modeling, and model evolvability, are gaining higher priority from CSES users when evaluating different modeling methodologies for CSES. Traditional CSES modeling methodologies are either domain-neutral (lack of domain characteristics consideration and limited support for model composability) or domain-oriented (lack of openness and evolvability) and fall short of the three NFRs. Inspired by the concept of architecture in systems engineering and software engineering fields, we extend it into a concept of model architecture for complex simulation systems, and propose a model architecture-oriented modeling methodology in which the model architecture plays a central role in achieving the three NFRs. Various model-driven engineering (MDE) approaches and technologies, including simulation modeling platform (SMP), unified modeling language (UML), domain specific modeling (DSM), eclipse modeling framework (EMF), graphical modeling framework (GMF), and so forth, are applied where possible in representing the CSES model architecture and its components' behaviors from physical and cognitive domain aspects. A prototype CSES system, called weapon effectiveness simulation system (WESS), and a non-trivial air-combat simulation example are presented to demonstrate the methodology.

Simulation studies make use of various types of simulation experiments. For users, specifying these experiments is a demanding task since the specification depends on the experiment type and the idiosyncrasies of the used tools. Thus, we present an experiment generation procedure that guides users through the specification process, and abstracts away from the concrete execution environment. This abstraction is achieved by (1) developing schemas that define the properties of simulation experiments and dependencies between them, (2) specifying a mapping between schema properties and template fragments in the specification language of a target backend. We develop schema, template fragments, and mappings for stochastic discrete-event simulation, and show how the concepts can be transported to a different domain of modeling and simulation. Further, we expand the developed "simple" experiment schemas by a schema for experiment designs, and generate executable sensitivity analysis experiments, thereby demonstrating versatility and composability of our approach.

Composability is one of seven reasons for the long-standing and continuing success of MPI. Extending MPI by composing its operations with user-level operations provides useful integration with the progress engine and completion notification methods of MPI. However, the existing extensibility mechanism in MPI (generalized requests) is not widely utilized and has significant drawbacks. MPI can be generalized via scheduled communication primitives, for example, by utilizing implementation techniques from existing MPI-3 nonblocking collectives and from forthcoming MPI-4 persistent and partitioned APIs. Non-trivial schedules are used internally in some MPI libraries; but, they are not accessible to end-users. Message-based communication patterns can be built as libraries on top of MPI. Such libraries can have comparable implementation maturity and potentially higher performance than MPI library code, but do not require intimate knowledge of the MPI implementation. Libraries can provide performance-portable interfaces that cross MPI implementation boundaries. The ability to compose additional user-defined operations using the same progress engine benefits all kinds of general purpose HPC libraries. We propose a definition for MPI schedules: a user-level programming model suitable for creating persistent collective communication composed with new application-specific sequences of user-defined operations managed by MPI and fully integrated with MPI progress and completion notification. The API proposed offers a path to standardization for extensible communication schedules involving user-defined operations. Our approach has the potential to introduce event-driven programming into MPI (beyond the tools interface), although connecting schedules with events comprises future work. Early performance results described here are promising and indicate strong overlap potential.

Smart government widely integrates heterogeneous business systems to provide intelligent applications, and improving interdepartmental government coordination capability is a key technical issue that needs to be solved urgently. Service composition technology based on SOA architecture is a good solution. However, due to the inherent heterogeneity and huge scale of smart government, the state space of service composition is very large, which is a great challenge to the efficiency and accuracy of problem solving. Based on analysis of the existing service composition research methods, combined with the domain characteristics of smart government, this paper studies and constructs an abstract government Web service template to reduce the scale of state space for service composition problem. Furthermore, a semantic-based service composability measurement is studied to select service solutions to improve the accuracy.

Over the last few years, we have experienced a massive transformation of the Software Defined Networking ecosystem with the development of SDNEnhancements, e.g., Statesman, ESPRES, Pane, and Pyretic, to provide better composability, better utilization of TCAM, consistent network updates, or congestion free updates. The end-result of this organic evolution is a disconnect between the SDN applications and the data-plane. A disconnect which can impact an SDN application's performance and efficacy. In this paper, we present the first systematic study of the interactions between SDNEnhancements and SDN applications -- we show that an SDN application's performance can be significantly impacted by these SDNEnhancements: for example, we observed that the efficiency of a traffic engineering SDN application was reduced by 24.8%. Motivated by these insights, we present, Mozart, a redesigned SDN controller centered around mitigating and reducing the impact of these SDNEnhancements. Using two prototypes interoperating with seven SDN applications and two SDNEnhancements, we demonstrate that our abstractions require minimal changes and can restore an SDN application's performance. We analyzed Mozart's scalability and overhead using large scale simulations of modern cloud networks and observed them to be negligible.

Future intelligent management systems compose of heterogeneous devices with lots of applications cooperatively to analyze data. Recent advances in Service-Oriented Architecture (SOA) provide opportunities for solving this challenge with reusability, composability, and abstraction. In this paper, we develop an intelligent management platform using cloud computing and SOA. It provides different service modules to collect, store, analyze, and visualize the Internet of Things (IoT) data to fit Cyber-Physical System (CPS), all these functions are wrapped as RESTful APIs so it can be imported to other applications, making the same service can be reused to meet the requirements of different fields. In addition, an editable dynamic dashboard service is proposed to personalize the management demand in a click-and-drag way. Users can analyze and observe data for intelligent management. Finally, we apply these services to build three different applications to validate the power of our service platform.

Generating good random values described by algebraic data types is often quite intricate. State-of-the-art tools for synthesizing random generators serve the valuable purpose of helping with this task, while providing different levels of invariants imposed over the generated values. However, they are often not built for composability nor extensibility, a useful feature when the shape of our random data needs to be adapted while testing different properties or sub-systems. In this work, we develop an extensible framework for deriving compositional generators, which can be easily combined in different ways in order to fit developers' demands using a simple type-level description language. Our framework relies on familiar ideas from the a la Carte technique for writing composable interpreters in Haskell. In particular, we adapt this technique with the machinery required in the scope of random generation, showing how concepts like generation frequency or terminal constructions can also be expressed in the same type-level fashion. We provide an implementation of our ideas, and evaluate its performance using real-world examples.

Power and electromagnetic based side-channel attacks are serious threats against the security of cryptographic embedded devices. In order to mitigate these attacks, implementations use countermeasures, among which masking is currently the most investigated and deployed choice. Unfortunately, commonly studied forms of masking rely on underlying assumptions that are difficult to satisfy in practice. This is due to physical defaults, such as glitches or transitions, which can recombine the masked data in a way that concretely reduces an implementation’s security.

This paper presents Polycube, an open-source softwareframework based on eBPF, that enables the creation ofarbitrary and complex network function chains. Each functioncan include an efficient in-kernel data plane and a flexible userspacecontrol plane with strong characteristics of isolation, persistence(e.g., across server reboots) and composability. In addition,a generic model for the control and management plane of eachnetwork function simplifies the manageability and accelerates thedevelopment of new network services. We validate the frameworkby creating different network services and benchmarking theirperformance in a complex scenario, namely a network providerfor Kubernetes. Results show that Polycube programs are about20x shorter than equivalent programs implemented with vanilla eBPF.

Composability is a key component to improve programmers’ productivity in writing fast market-expanding applications such as parallel machine learning algorithms and big data analytics. These applications exhibit both regular and irregular compute patterns, and are often combined with other functions or libraries to compose a larger program. However, composable parallel processing has taken a back seat in many existing parallel programming libraries, making it difficult to achieve modularity in large-scale parallel programs. In this paper, we introduce a new parallel task programming library using composable tasking graphs. Our library efficiently supports task parallelism together with an intuitive task graph construction and flexible execution API set to enable reusable and composable task dependency graphs. Developers can quickly compose a large parallel program from small and modular parallel building blocks, and easily deploy the program on a multicore machine. We have evaluated our library on real-world applications. Experimental results showed our library can achieve comparable performance to Intel Threading Building Blocks with less coding effort.

Developments in information technology have challenged the traditional model of museums, libraries and similar venues acting as relatively passive ‘learning spaces’ for the public to access ‘knowledge’ as an exchange between tutor and learner, or in this context curator and visitor enabling them to offer more immersive and interactive modes of transfer. This article examines the development of a 3D model built from plans of a Roman edifice and its transfer into four game engines as vehicles for independent navigation around the ‘virtual building’. The game engines are evaluated in respect of their ability to enhance visitors’ experience by using an on-site facility when visiting a museum constructed over the physical remains. Cost and licensing override technical factors such as audiovisual and functional fidelity or composability and installing the system on a PC is preferable to more specialist game control devices if a broad user base is targeted.

Convolutional Neural Networks (CNN) are widely used for Deep Learning tasks. CNN pruning is an important method to adapt a large CNN model trained on general datasets to fit a more specialized task or a smaller device. The key challenge is on deciding which filters to remove in order to maximize the quality of the pruned networks while satisfying the constraints. It is time-consuming due to the enormous configuration space and the slowness of CNN training. The problem has drawn many efforts from the machine learning field, which try to reduce the set of network configurations to explore. This work tackles the problem distinctively from a programming systems perspective, trying to speed up the evaluations of the remaining configurations through computation reuse via a compiler-based framework. We empirically uncover the existence of composability in the training of a collection of pruned CNN models, and point out the opportunities for computation reuse. We then propose composability-based CNN pruning, and design a compression-based algorithm to efficiently identify the set of CNN layers to pre-train for maximizing their reuse benefits in CNN pruning. We further develop a compiler-based framework named Wootz, which, for an arbitrary CNN, automatically generates code that builds a Teacher-Student scheme to materialize composability-based pruning. Experiments show that network pruning enabled by Wootz shortens the state-of-art pruning process by up to 186X while producing significantly better pruning results.

Composing together the individual atomic methods of concurrent data-structures (cds) pose multiple design and consistency challenges. In this context composition provided by transactions in software transaction memory (STM) can be handy. However, most of the STMs offer read/write primitives to access shared cds. These read/write primitives result in unnecessary aborts. Instead, semantically rich higher-level methods of the underlying cds like lookup, insert or delete (in case of hash-table or lists) aid in ignoring unimportant lower level read/write conflicts and allow better concurrency.

The complexity of large-scale distributed systems, particularly when deployed in physical space, calls for new mechanisms to address composability and reusability of collective adaptive behaviour. Computational fields have been proposed as an effective abstraction to fill the gap between the macro-level of such systems (specifying a system's collective behaviour) and the micro-level (individual devices' actions of computation and interaction to implement that collective specification), thereby providing a basis to better facilitate the engineering of collective APIs and complex systems at higher levels of abstraction. This paper proposes a full formal foundation for field computations, in terms of a core (higher-order) calculus of computational fields containing a few key syntactic constructs, and equipped with typing, denotational and operational semantics. Critically, this allows formal establishment of a link between the micro- and macro-levels of collective adaptive systems, by a result of full abstraction and adequacy for the (aggregate) denotational semantics with respect to the (per-device) operational semantics., 39 pages, 12 figures

Many peer-organizations are now using process-aware information systems for managing their organizational processes. Most of these peer-organizations have shared processes, which include many commonalities and some degrees of variability. Analyzing and mining the commonalities of these processes can have many benefits from the reusability point of view. In this paper, we propose an approach for extracting common process fragments from a collection of event logs. To this end, we first analyze the process fragment literature from a theoretical point of view, based on which we present a new process fragment definition, called morphological fragments to support composability and flexibility. Then we propose a novel algorithm for extracting such morphological fragments directly from process event logs. This algorithm is capable of eliciting common fragments from a family of processes that may not have been executed within the same application/organization. We also propose supporting algorithms for detecting and categorizing morphological fragments for the purpose of reusability. Our empirical studies show that our approach is able to support reusability and flexibility in process fragment identification.

The service oriented architecture (SOA) approach constitutes an ideal solution for distributed application development. However, its success is conditioned by a solution to the problem of dynamic service composition. The formal-based tools are ones of the promising solutions to this problem, because of their mathematical-basis who can provide possibility of doing computation on services behavior in order to confirm the existence or not of some particular behaviours. In this paper, the authors present an approach based on model transformation (MT) for checking behavioural compatibility between services. Elementary services behaviours, modelled as OWFNet, an extenstion of Petri Nets, are automatically translated to a LOTOS specification. The translation is done by a two-fold transformation, model to model (M2M) and model to text (M2T). The resulting Lotos text specification is submitted to a LOTOS toolkit to check service composability.

This paper presents an approach for constructing an adaptive mesh refinement (AMR) scheme, targeting next-generation computing hardware. The key to the design is the particular combination of aspects of cell-based AMR and patch-based AMR. We examine the feasibility of this new method with respect to correctness, preservation of circular symmetry, ease of programming and performance impacts on runtime and memory usage. This method exploration is done in CLAMR, a cell-based AMR mini-app that already runs on GPUs and other next-generation hardware platforms. The composability of the application is improved by decoupling the physics code and mesh code. Each level of the mesh is made independent through the use of phantom cells. The net result is a clear pathway to getting the full application on the GPU while also minimizing development requirements to convert a regular grid application to AMR.

We present a framework called Composable Modular Design (CMD) to facilitate the design of out-of-order (OOO) processors. In CMD, (1) The interface methods of modules provide instantaneous access and perform atomic updates to the state elements inside the module; (2) Every interface method is guarded, i.e., it cannot be applied unless it is ready; and (3) Modules are composed together by atomic rules which call interface methods of different modules. A rule either successfully updates the state of all the called modules or it does nothing. CMD designs are compiled into RTL which can be run on FPGAs or synthesized using standard ASIC design flows. The atomicity properties of interfaces in CMD ensures composability when selected modules are refined selectively. We show the efficacy of CMD by building a parameterized out-of-order RISC-V processor which boots Linux and runs on FPGAs at 25 MHz to 40 MHz. We also synthesized several variants of it in a 32 nm technology to run at 1 GHz to 1.1 GHz. Performance evaluation shows that our processor beats in-order processors in terms of IPC but will require more architectural work to compete with wider superscalar commercial ARM processors. Modules designed under the CMD framework (e.g., ROB, reservation stations, load store unit) can be used and refined by other implementations. We believe that this realistic framework can revolutionize architectural research and practice as the library of reusable components grows.

Service oriented architecture is widely accepted for designing the projects because it provides reusability, composability, interoperability, distributed deployment. But security is always a concern for this architecture. Security implementation is normally ignored to keep services more reusable and interoperable which causes incidents at the later stage. Service oriented architectural project uses tools like IBM data power for providing security to end users at higher level of service oriented architecture. But the lower levels of SOA remain unsecured. It has also been observed that some unauthorized vendor uses the service illegally which causes heavy load on the exposed service results into slowing down the performance of the specific service.Service-oriented architecture (SOA) is a technique to develop application by assembling different services. It’s an approach to make applications more responsive to meet the requirement of changing business environment. A single application uses many services to meet the consumer requirement where in services are independent entities. The incorporation different security techniques for the services within an application is a difficult task. So, security implementation at service level is generally ignored for service oriented architectural project. The author(s) proposes a model which will enhance the security implementation at service level. Also, similar security implementation can be done for all services within an application. The proposed model will reduce the unauthorize use of service at lower level in SOA. Also, Security and reliability will be enhanced for each service.

It is standard practice that the secret key derived from an execution of a Password Authenticated Key Exchange (PAKE) protocol is used to authenticate and encrypt some data payload using a Symmetric Key Protocol (SKP). Unfortunately, most PAKEs of practical interest are studied using so-called game-based models, which -- unlike simulation models -- do not guarantee secure composition per se. However, Brzuska et al. (CCS 2011) have shown that a middle ground is possible in the case of authenticated key exchange that relies on Public-Key Infrastructure (PKI): the game-based models do provide secure composition guarantees when the class of higher-level applications is restricted to SKPs. The question that we pose in this paper is whether or not a similar result can be exhibited for PAKE. Our work answers this question positively. More specifically, we show that PAKE protocols secure according to the game-based Real-or-Random (RoR) definition with the weak forward secrecy of Abdalla et al. (S&P 2015) allow for safe composition with arbitrary, higher-level SKPs. Since there is evidence that most PAKEs secure in the Find-then-Guess (FtG) model are in fact secure according to RoR definition, we can conclude that nearly all provably secure PAKEs enjoy a certain degree of composition, one that at least covers the case of implementing secure channels.

We present a novel Proof-of-Stake (PoS) protocol, Ouroboros Genesis,, that enables parties to safely join (or rejoin) the protocol execution using only the genesis block information. Prior to our work, PoS protocols either required parties to obtain a trusted "checkpoint" block upon joining and, furthermore, to be frequently online or required an accurate estimate of the number of online parties to be hardcoded into the protocol logic. This ability of new parties to "bootstrap from genesis" was a hallmark property of the Bitcoin blockchain and was considered an important advantage of PoW-based blockchains over PoS-based blockchains since it facilitates robust operation in a setting with dynamic availability, i.e., the natural setting---without external trusted objects such as checkpoint blocks---where parties come and go arbitrarily, may join at any moment, or remain offline for prolonged periods of time. We prove the security of Ouroboros Genesis against a fully adaptive adversary controlling less than half of the total stake in a partially synchronous network with unknown message delay and unknown, varying levels of party availability. Our security proof is in the Universally Composable setting assuming the most natural abstraction of a hash function, known as the strict Global Random Oracle (ACM-CCS 2014); this highlights an important advantage of PoS blockchains over their PoW counterparts in terms of composability with respect to the hash function formalisation: rather than a strict GRO, PoW-based protocol security requires a "local" random oracle. Finally, proving the security of our construction against an adaptive adversary requires a novel martingale technique that may be of independent interest in the analysis of blockchain protocols.

Program analyses are an important tool to check if a system fulfills its specification. A typical implementation strategy for program analyses is to use an imperative, general-purpose language like Java; and access the program to be analyzed through libraries for manipulating intermediate code, such as ASM for Java bytecode. We show that this hampers composability, interoperability and reuse of analysis implementations. We propose a complete Ecore-metamodel for Java bytecode as a common basis for program analysis implementations, as well as an Eclipse plug-in to create bytecode metamodel instances from Java bytecode and vice versa. Code analyses can be defined as model transformations in a declarative, domain-specific language. As a consequence, the implementations of program analyses become more composable and more modular in general. We demonstrate the effectiveness of this approach with a case study.

We demonstrate how methods in Functional Programming can be used to implement a computer algebra system. As a proof-of-concept, we present the computational-algebra package. It is a computer algebra system implemented as an embedded domain-specific language in Haskell, a purely functional programming language. Utilising methods in functional programming and prominent features of Haskell, this library achieves safety, composability, and correctness at the same time. To demonstrate the advantages of our approach, we have implemented advanced Grobner basis algorithms, such as Faugere’s \(F_4\) and \(F_5\), in a composable way.