Search

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.

International audience; 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. We develop and implement an automated approach for verifying security of masked implementations in presence of physical defaults (glitches or transitions). Our approach helps to recover the main strengths of masking: rigorous foundations, composability guarantees, automated verification under more realistic assumptions. Our work follows the approach of (Barthe et al, EUROCRYPT 2015) and thus contributes to demonstrate the benefits of language-based approaches (specifically probabilistic information flow) for masking.

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.

We revisit the gap between what distributed systems need from the transport layer and what protocols in wide deployment provide. Such a gap complicates the implementation of distributed systems and impacts their performance. We introduce Tunable Multicast Communication (TMC), an abstraction that allows developers to easily specialize communication channels in distributed systems. TMC is presented as a deployable and extensible user-space library that exposes high-level tunable guarantees. TMC has the potential of improving the performance of distributed applications with minimal-to-zero development and deployment effort.

A permutation class C is said to be splittable if there exist two proper subclasses A , B ⊊ C such that any σ ∈ C can be red–blue colored so that the red (respectively, blue) subsequence of σ is order isomorphic to an element of A (respectively, B ). The class C is said to be composable if there exists some number of proper subclasses A 1 , … , A k ⊊ C such that any σ ∈ C can be written as α 1 ∘ ⋯ ∘ α k for some α i ∈ A i . We answer a question of Karpilovskij by showing that there exists a composable permutation class that is not splittable. We also give a condition under which an infinite composable class must be splittable.

The demand for low cost high quality products is continuing to grow in the marketplace. Technology and the advent of robotic engineering have paved the way to reduce cost of manufacturing, and, yet, the cost of test and its resulting test equipment is still high. How, then, do we approach the problem of reducing the cost of test and, at the same time, streamline the assembly and test flow? The answer lies in establishing a Composable Test Architecture, which utilizes common test methods (CTM) for testing functions and defines composable test systems to test those functions. Most products can be decomposed into key functions, encapsulated within a system utilizing a modular open system architecture. Specific modular systems can then be selected and composed into a more complex product, such as a smartphone, to satisfy the user's needs without losing any of its core functionality. Thus, the modular product can also be called a composable system, to which common test methods can be applied and subsequent composable test systems aligned to the modular product can be developed. By defining a standard methodology for testing each composable system in a product, the cost of test can be reduced by reusing those CTMs for new product development. The end result is the establishment of a composable test library that includes 1) the CTMs which define the test methodology, or “how to test”, for each composable system, and 2) the corresponding composable test equipment used to test the composable system. Composable test equipment is comprised of a standardized set of test instruments performing a standard list of test measurements. As the end product is built up, the same set of test instruments and measurements can be utilized at the next level of assembly to ensure the final product still meets requirements. This paper discusses the principles behind composable systems and how that can be leveraged to build composable test equipment. The conclusion will demonstrate how implementing a composable test architecture can shorten the test equipment development cycle and streamline test in the factory.

Colored Petri Net (CPN) is a graphical modeling language for simulation and modeling and for verification of discrete event systems. CPN allows developers to define a model in the form of reusable components. A model component is an independent element, which is specified using a formalized description, can conform to a certain component standard, has a well-defined interface, and encapsulates certain behavior. Modern components can help the developer reuse existing models according to their requirement as it reduces the cost and time of development. Composability is the capability to select and integrate various components to fulfill user requirements. Composability provides the means to achieve reusability where "reuse" is the ability of a simulation component to be reclaimed for various applications. We propose a verification framework for developers to select and assemble CPN-based components and verify their composability. The goal of this paper is to provide a pattern which helps developer in making models of concurrent systems. We present a case study of a restaurant model as proof of concept. A verified composition affirms reuse of model components in a meaningful manner by satisfying given requirement specifications.

Biological regulatory networks depend upon chemical interactions to process information. Engineering such molecular computing systems is a major challenge for synthetic biology and related fields. The chemical reaction network (CRN) model idealizes chemical interactions, allowing rigorous reasoning about the computational power of chemical kinetics. Here we focus on function computation with CRNs, where we think of the initial concentrations of some species as the input and the equilibrium concentration of another species as the output. Specifically, we are concerned with CRNs that are rate-independent (the computation must be correct independent of the reaction rate law) and composable ($f\circ g$ can be computed by concatenating the CRNs computing $f$ and $g$). Rate independence and composability are important engineering desiderata, permitting implementations that violate mass-action kinetics, or even "well-mixedness", and allowing the systematic construction of complex computation via modular design. We show that to construct composable rate-independent CRNs, it is necessary and sufficient to ensure that the output species of a module is not a reactant in any reaction within the module. We then exactly characterize the functions computable by such CRNs as superadditive, positive-continuous, and piecewise rational linear. Thus composability severely limits rate-independent computation unless more sophisticated input/output encodings are used., Appeared at Computational Methods in Systems Biology (CMSB) 2018 (best paper award) To appear in IEEE/ACM Transactions on Computational Biology and Bioinformatics

Hybrid practices are emerging that integrate creative materials like paint, clay, and cloth with intangible immaterials like computation, electricity, and heat. This work aims to expand the design potential of immaterial elements by transforming them into manipulatable, observable and intuitive materials. We explore one such immaterial, electric heat, and develop a maker-friendly fabrication pipeline and crafting support tool that allows users to experientially compose resistive heaters that generate heat spatially and temporally. These heaters are then used to couple heat and thermoreactive materials in a class of artifacts we term Thermoreactive Composites (TrCs). In a formal user study, we observe how designing fabrication workflows along dimensions of composability and perceivability better matches the working styles of material practitioners without domain knowledge of electronics. Through exemplar artifacts, we demonstrate the potential of heat as a creative material and discuss implications for immaterials used within creative practices.

Part 2: Short and “Journal First” Papers; International audience; Computational fields have been proposed as an effective abstraction to fill the gap between the macro-level of distributed 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 approach is particularly suited to complex large-scale distributed systems, like the Internet-of-Things and Cyber-Physical Systems, where new mechanisms are needed to address composability and reusability of collective adaptive behaviour. This work introduces a full formal foundation for field computations, in terms of a core calculus equipped with typing, denotational, and operational semantics. Critically, we apply techniques for formal programming languages to collective adaptive systems: we provide formal establishment of a link between the micro- and macro-levels of collective adaptive systems, via a result of computational adequacy and abstraction for the (aggregate) denotational semantics with respect to the (per-device) operational semantics.

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.

In recent engineering practice, the complexity of the systems is increasing. This complexity will keep on increasing if new components are added into the system or system configuration is changed. Numerous configurations of these components are repeated or their relationship is recognizable. On the other hand, simulation tools are commonly used to track the behavior of the modeled systems over time because of their advantages against experimental setups which are the abstraction of reality. However, the ability to integrate different components at different levels of the designed model along with the different techniques used for their inter-relationships based on users requirement is a challenge. The main contribution of this paper is to give an example of how to apply composability to handle this issue. One tangible example is to study the behavior of heating, ventilation, and air-conditioning systems in large buildings. Therefore, finding a solution to model this kind of complex system in a highly composable and scalable view is promising. Composability is a system design challenge that describes how different components can be selected and combined in different configurations and different levels to satisfy users requirement with a highly reduced development cost and time in the simulation, as its advantages. Finally, the practical steps for design and implementation of a composable demand-controlled ventilation and heating system as a useful and energy-efficient smart building's technology in MATLAB/Simulink (besides its constraints) is provided.

We study the composability of discrete chemical reaction networks (CRNs) that stably compute (i.e., with probability 0 of error) integer-valued functions $$f:\mathbb {N}^d\rightarrow \mathbb {N}$$. We consider output-oblivious CRNs in which the output species is never a reactant (input) to any reaction. The class of output-oblivious CRNs is fundamental, appearing in earlier studies of CRN computation, because it is precisely the class of CRNs that can be composed by simply renaming the output of the upstream CRN to match the input of the downstream CRN. Our main theorem precisely characterizes the functions f that are stably computable by output-oblivious CRNs with an initial leader. The key necessary condition is that for sufficiently large inputs, f is the minimum of a finite number of nondecreasing quilt-affine functions (an affine function is linear with a constant offset; a quilt-affine function is linear with a periodic offset).

We improve the state-of-the-art masking schemes in two important directions. First, we propose a new masked multiplication algorithm that satisfies a recently introduced notion called Probe-Isolating Non-Interference (PINI). It captures a sufficient requirement for designing masked implementations in a trivial way, by combining PINI multiplications and linear operations performed share by share. Our improved algorithm has the best reported randomness complexity for large security orders (while the previous PINI multiplication was best for small orders). Second, we analyze the security of most existing multiplication algorithms in the literature against so-called horizontal attacks, which aim to reduce the noise of the actual leakages measured by an adversary, by combining the information of multiple target intermediate values. For this purpose, we leave the (abstract) probing model and consider a specialization of the (more realistic) noisy leakage / random probing models. Our (still partially heuristic but quantitative) analysis allows confirming the improved security of an algorithm by Battistello et al. from CHES 2016 in this setting. We then use it to propose new improved algorithms, leading to better tradeoffs between randomness complexity and noise rate, and suggesting the possibility to design efficient masked multiplication algorithms with constant noise rate in F2., IACR Transactions on Cryptographic Hardware and Embedded Systems, Volume 2019, Issue 2

In this chapter, we discuss composability: what it is, what characteristics make Threading Building Blocks (TBB) a composable threading library, and how to use a library like TBB to create scalable applications. C++ is a composable language, and TBB adds parallelism in a way that maintains composability. Composability with TBB is highly valuable because it means we are free to expose opportunities for parallelism without worrying about overloading the system. If we do not expose parallelism, we limit scaling.

Behavior Trees (BTs) are becoming a popular tool to model the behaviors of autonomous agents in the computer game and the robotics industry. One of the key advantages of BTs lies in their composability, where complex behaviors can be built by composing simpler ones. The parallel composition is the one with the highest potential since the complexity of composing pre-existing behaviors in parallel is much lower than the one needed using classical control architectures as finite state machines. However, the parallel composition is rarely used due to the underlying concurrency problems that are similar to the ones faced in concurrent programming. In this paper, we define two synchronization techniques to tackle the concurrency problems in BTs compositions and we show how to exploit them to improve behavior predictability. Also, we introduce measures to assess execution performance, and we show how design choices can affect them. To illustrate the proposed framework, we provide a set of experiments using the R1 robot and we gather statistically-significant data., Comment: Preprint of IROS19

While many tailor made card game protocols are known, the vast majority of those lack three important features: mechanisms for distributing financial rewards and punishing cheaters, composability guarantees and flexibility, focusing on the specific game of poker. Even though folklore holds that poker protocols can be used to play any card game, this conjecture remains unproven and, in fact, does not hold for a number of protocols (including recent results). We both tackle the problem of constructing protocols for general card games and initiate a treatment of such protocols in the Universal Composability (UC) framework, introducing an ideal functionality that captures card games that use a set of core card operations. Based on this formalism, we introduce Royale, the first UC-secure general card games which supports financial rewards/penalties enforcement. We remark that Royale also yields the first UC-secure poker protocol. Interestingly, Royale performs better than most previous works (that do not have composability guarantees), which we highlight through a detailed concrete complexity analysis and benchmarks from a prototype implementation.

Complex systems usually have to deal with a huge number of potential situations and contingencies. Therefore, a mechanism is required that enables the expression of variability at design-time so that it can be efficiently resolved at run-time. As composability plays an increasingly relevant role in building systems in an economic way, variability management should also contribute to and be taken into account in terms of composability. This chapter presents a variability management workflow aimed at supporting different developer roles in an ecosystem context. Two kinds of variability are addressed: in system operation and associated with quality of service. The former provides robustness to contingencies, while the latter focuses on the quality of the application (in terms of non-functional properties) under changing situations and limited resources. The concepts introduced in this chapter conform to the structures and principles of the H2020 European Project RobMoSys, which consolidates composability in the robotics domain.

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.

Model composition is combining separate models into an integrated composite model. Composability is the capability to select and compose models in various combinations into simulation systems to satisfy specific user requirements. Composability has been an important research objective for some time, especially in the defense-related modeling and simulation community, but general composability remains a challenging goal. Model reuse is reusing an existing model for a new application. Reuse can reduce the time, effort, and expense of model development and testing. Because the models to be reused are usually implemented as software components, general software reuse techniques are often applicable. In addition, frameworks and standards specific to modeling and simulation have developed to support model composition and reuse. Model composition and reuse are closely related. Composability is an important enabler for reuse, and reusing a software implementation of a model may require that it be composable.

Domain Specific Languages (DSLs) bridge the gap between the business model and the technical model. DSLs allow the technical developer to write programs with the business domain notations. This leads to higher productivity and better quality than General Purpose Languages (GPLs). One of the main challenges of utilizing DSLs in the current software process is how to reduce the implementation cost and the knowledge required for building and maintaining DSLs. Language workbenches are environments that provide high level tools for implementing different language aspects. The purpose of this paper is to provide a survey on the different aspects of implementing DSLs. The survey includes structure, editor, semantics, and composability language aspects. Furthermore, it overviews the approaches used for each aspect and classify the current workbenches according to these approaches.

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

This paper presents a structural geometry for increasing piezoelectric deformation, which is suitable for both micro- and macro-scale applications. New and versatile microstructure geometries for actuators can improve device performance, and piezoelectric designs benefit from a high-frequency response, power density, and efficiency, making them a viable choice for a variety of applications. Previous works have presented piezoelectric structures capable of this amplification, but few are well-suited to planar manufacturing. In addition to this manufacturing difficulty, a large number of designs cannot be chained into longer elements, preventing them from operating at the macro-scale. By optimizing for both modern manufacturing techniques and composability, this structure excels as an option for a variety of macro- and micro-applications. This paper presents an analytical compact model of a novel dual-bimorph piezoelectric structure, and shows that this compact model is within 2% of a computer-distributed element model. Furthermore it compares the actuator’s theoretical performance to that of a modern actuator, showing that this actuator trades mechanical efficiency for compactness and weight savings.

Modeling languages are defined with a meta-model, which are specified using the meta-modeling tools that produce the editors for specifying models in accordance with the meta-models. In this paper, we aim to understand the top-used meta-modeling tools and practitioners’ expectations and challenges with respect to different requirements. So, we designed and conducted a survey, which was responded by 103 practitioners. The questionnaire considers the notation, semantics, editor services, model-transformation, validation, testing, and composability requirements. Some of the results are as follows: the top-used meta-modeling tools are Sirius and GEMS, Metaedit+, Xtext, and Microsoft DSL tools respectively. The top-preferred language visualizations are diagrammatic or textual. Practitioners prefer the editors with free-editing mode and are not familiar with projectional editing that promotes hybrid modeling. Translational semantics definition (i.e., model-to-model and model-to-text) is more popular than the interpretative semantics definition. Importing/exporting models and meta-models is highly important for facilitating the communication and collaboration. Modeling and meta-modeling with re-use and their versioning are among the top-desired features. Practitioners are willing to integrate any validation tools (e.g., model checkers) to define the languages’ semantical and structural validation rules and prove the model correctness. Lastly, defining the language semantics by composition and testing the semantics definitions are crucial for many practitioners. The survey also reveals many important challenges in each type of requirements. The survey results will be useful for meta-modelers in analyzing the meta-modeling tools and tool vendors in learning practitioners’ expectations.

Multi-Processor Systems-on-a-Chip (MPSoCs) provide sufficient computing power for many applications in scientific as well as embedded applications. Unfortunately, when real-time requirements need to be guaranteed, applications suffer from the interference with other applications, uncertainty of dynamic workload and state of the hardware. Composable application/architecture design and timing analysis is therefore a must for guaranteeing real-time applications to satisfy their timing requirements independent from dynamic workload. Here, Invasive Computing is used as the key enabler for compositional timing analysis on MPSoCs, as it provides the required isolation of resources allocated to each application. On the basis of this paradigm, this work proposes a hybrid application mapping methodology that combines design-time analysis of application mappings with run-time management. Design space exploration delivers several resource reservation configurations with verified real-time guarantees for individual applications. These timing properties can then be guaranteed at run-time, as long as dynamic resource allocations comply with the offline analyzed resource configurations. This article describes our methodology and presents programming, optimization, analysis, and hardware techniques for enforcing timing predictability. A case study illustrates the timing-predictable management of real-time computer vision applications in dynamic robot system scenarios.

Many solutions for composability and compositionality rely on specifying the interface for a component using bandwidth. Some previous works specify period (P) and budget (Q) as an interface for a component. Q/P provides us with a bandwidth (the share of a processor that this component may request); P specifies the time-granularity of the allocation of this processing capacity. Other works add another parameter deadline which can help to provide tighter bounds on how this processing capacity is distributed. Yet other works use the parameters α and Δ where α is the bandwidth and Δ specifies how smoothly this bandwidth is distributed. It is known [4] that such bandwidth-like interfaces carry a cost: there are tasksets that could be guaranteed to be schedulable if tasks were scheduled directly on the processor, but with bandwidth-like interfaces, it is impossible to guarantee the taskset to be schedulable. And it is also known that this penalty can be infinite, i.e., the use of bandwidth-like interfaces may require the use of a processor that has a speed that is k times faster, and one can show this for any k. This brings the question: "What is the average-case performance penalty of bandwidth-like interfaces?" This paper addresses this question. We answer the question by randomly generating tasksets and then for each of these tasksets, compute a lower bound on how much faster a processor needs to be when a bandwidth-like scheme is used. We do not consider any specific bandwidth-like scheme; instead, we derive an expression that states a lower bound on how much faster a processor needs to be when a bandwidth-like scheme is used. For the distributions considered in this paper, we find that (i) the experimental results depend on the experimental setup, (ii) this lower bound on the penalty was never larger than 4.0, (iii) for one experimental setup, for each taskset, it was greater than 2.4, (iv) the histogram of this penalty appears to be unimodal, and (v) for implicit-deadline sporadic tasks, this lower bound on the penalty was exactly 1.

Compositional theories and technologies facilitate the decomposition of a complex system into components, as well as their integration via interfaces. Component interfaces hide the internal details of the components, thereby reducing integration complexity. A system is said to be composable if the properties established and validated for components in isolation hold once the components are integrated to form the system. This brings us the question: "Is compositionality related to composability?" This paper answers this question in the affirmative; it considers a previously known interface for compositionality and shows that it can be used for composability. It also presents a run-time policing mechanism for this interface.

[EN] Elasticity is a goal of cloud computing. An elastic system should manage in an autonomic way its resources, being adaptive to dynamic workloads, allocating additional resources when workload is increased and deallocating resources when workload decreases. PaaS providers should manage resources of customer applications with the aim of converting those applications into elastic services. This survey identifies the requirements that such management imposes on a PaaS provider: autonomy, scalability, adaptivity, SLA awareness, composability and upgradeability. This document delves into the variety of mechanisms that have been proposed to deal with all those requirements. Although there are multiple approaches to address those concerns, providers main goal is maximisation of profits. This compels providers to look for balancing two opposed goals: maximising quality of service and minimising costs. Because of this, there are still several aspects that deserve additional research for finding optimal adaptability strategies. Those open issues are also discussed., This work has been partially supported by EU FEDER and Spanish MINECO under research Grant TIN2012-37719-C03-01.

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.

Yao et al. (A note on the feasibility of generalized universal composability.Theory and Applications of Models of Computationpp. 474–485, 2007; A note on the feasibility of generalised universal composability.Mathematical Structures in Computer Science,19(1), pp. 193–205) claimed a potential limitation on the class of protocols that could be securely implemented in the generalized universal composability (GUC) framework proposed by Canetti et al. (Universally composable security with global setup.Lecture Notes in Computer Science, pp. 61–85, 2007). Specifically, Yao et al. presented a concrete attack on a GUC Zero Knowledge (GUCZK) protocol, a natural adaptation Blum's ZK proof for Directed Hamiltonicity using the general GUC feasibility of Canetti et al. (Universally composable security with global setup.Lecture Notes in Computer Science, pp. 61–85, 2007). Interestingly, the attack was not analysed in the GUC model in Yao et al. (A note on the feasibility of generalised universal composability.Mathematical Structures in Computer Science19(1), pp. 193–205, 2009) but in theFUC model, a new UC-like framework proposed in the same work. Nonetheless, Yao et al. (A note on the feasibility of generalised universal composability.Mathematical Structures in Computer Science19(1), pp. 193–205, 2009) argued that, in light of this attack, GUC would lose its concurrent general composability and proof of knowledge properties. Concretely, they argue that GUC composability would now be with respect to some adversaries with limited access to external arbitrary protocols.In this work, we show that the claimed attack from Yao et al. is indeed harmless and does not contradict the security of the mentioned GUCZK protocol, thus restoring the general feasibility for GUC.

Combat system effectiveness simulation (CoSES) plays an irreplaceable role in the effectiveness measurement of combat systems. According to decades of research and practice, composable modeling and multidomain modeling are recognized as two major modeling requirements in CoSES. Current effectiveness simulation researches attempt to cope with the structural and behavioral complexity of CoSES based on a unified technological space, and they are limited to their existing modeling paradigms and fail to meet these two requirements. In this work, we propose a model framework-based domain-specific composable modeling method to solve this problem. This method builds a common model framework using application invariant knowledge for CoSES, and designs domain-specific modeling infrastructures for subdomains as corresponding extension points of the framework to support the modeling of application variant knowledge. Therefore, this method supports domain-specific modeling in multiple subdomains and the composition of subsystem models across different subdomains based on the model framework. The case study shows that this method raises the modeling abstraction level, supports generative modeling, and promotes model reuse and composability.

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.

Industry 4.0 adoption demands integrability, interoperability, composability, and security. Currently, integrability, interoperability and composability are addressed by next-generation approaches for enterprise systems integration such as model-based standards, ontology, business process model life cycle management and the context of business processes. Security is addressed by conducting risk management as a first step. Nevertheless, security risks are very much influenced by the assets that the business processes are supported. To this end, this paper proposes an approach for automated risk estimation in smart sensor environments, called ARES, which integrates with the business process model life cycle management. To do so, ARES utilizes standards for platform, vulnerability, weakness, and attack pattern enumeration in conjunction with a well-known vulnerability scoring system. The applicability of ARES is demonstrated with an application example that concerns a typical case of a microSCADA controller and a prototype tool called Business Process Cataloging and Classification System. Moreover, a computer-aided procedure for mapping attack patterns-to-platforms is proposed, and evaluation results are discussed revealing few limitations.

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.

This study optimizes service composition on the basis of task requirements to solve the problem of multitask corresponding multi-service selection. First, the basic path structure and the implementation steps of cloud manufacturing (CMfg) service composition are analyzed, and service composition is divided into four patterns. Second, the quality of service (QoS) index system of service composition is proposed by combining the six goals of time, composability, quality, usability, reliability, and cost; the calculation expressions of QoS under different composition structures are listed; and the mathematical model of CMfg service composition is established. Then, the weight of each index value in QoS evaluation is determined using an improved fuzzy comprehensive evaluation method. Finally, the optimal selection scheme of service composition is proposed by using gray relational analysis method(GM), and the validity of the optimal selection scheme is verified by an example of mold manufacturing.

The drive for ever-increasing materials and energy efficiency and associated cost savings has compelled manufacturers to adopt flexible and rapid production systems. The technical limitations and sustainability concerns of conventional unit processes and sequential process flows have led to widespread adoption of advanced manufacturing processes that exhibit cyclic nature, termed cyclic manufacturing processes. While cyclic manufacturing processes enable efficient production through reduced time-to-market, lower production costs, and shorter manufacturing process chains, relatively little attention has been paid toward characterising their associated environmental, economic, and social impacts. A holistic manufacturing process modelling framework is developed to support sustainability performance characterisation of cyclic manufacturing processes. The developed framework enables model reusability, extensibility, and composability to characterise, assess, and extract product and process sustainability information. It is applied to characterise environmental impacts of a low-cost, hybrid (additive-subtractive) process for production of polylactide (PLA) parts, and compared with a conventional subtractive process (milling).

The use of microservices is a new trend in software engineering, dividing an application into several services. This concept allows programmers to write each microservice code using the better language and framework they know. We perceive that research on microservices aims mainly at composability, portability, and interface, leaving uncovered in surveys relevant quality concerns. Therefore, this article reports a survey focused on providing classification and analysis of studies on evaluating and improving performance in microservice-based applications. Our contributions are threefold: 1) an in-depth analysis of state of the art on microservices through the lens of performance; 2) a novel taxonomy to reclassify the current microservice initiatives, looking at software and hardware aspects that interfere in the execution of the application; 3) an analysis of trends and open research opportunities in the joint combination of performance and scalability applied to microservices. The article supports developers and organisations in defining standards, strategies, and technologies to model and code microservices applications by presenting practical and theoretical issues.

Unexpectedly, the rise of serverless computing has also collaterally started the "democratization" of massive-scale data parallelism. This new trend heralded by PyWren pursues to enable untrained users to execute single-machine code in the cloud at massive scale through platforms like AWS Lambda. Inspired by this vision, this industry paper presents IBM-PyWren, which continues the pioneering work begun by PyWren in this field. It must be noted that IBM-PyWren is not, however, just a mere reimplementation of PyWren's API atop IBM Cloud Functions. Rather, it is must be viewed as an advanced extension of PyWren to run broader MapReduce jobs. We describe the design, innovative features (API extensions, data discovering & partitioning, composability, etc.) and performance of IBM-PyWren, along with the challenges encountered during its implementation.

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.

The entropy of Boltzmann-Gibbs, as proved by Shannon and Khinchin, is based on four axioms, where the fourth one concerns additivity. The group theoretic entropies make use of formal group theory to replace this axiom with a more general composability axiom. As has been pointed out before, generalised entropies crucially depend on the number of allowed number degrees of freedom $N$. The functional form of group entropies is restricted (though not uniquely determined) by assuming extensivity on the equal probability ensemble, which leads to classes of functionals corresponding to sub-exponential, exponential or super-exponential dependence of the phase space volume $W$ on $N$. We review the ensuing entropies, discuss the composability axiom, relate to the Gibbs' paradox discussion and explain why group entropies may be particularly relevant from an information theoretic perspective., 12 pages - invited contribution to the journal Entropy's special issue "Nonadditive Entropies and Complex Systems"

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.

From mobile sensor networks to autonomous transportation systems, multi-agent solutions have been proposed to accomplish a variety of tasks. However, these systems typically require satisfaction of multiple constraints, such as safety or connectivity maintenance, while completing their primary objectives. Barrier functions represent one method to enforce such constraints via forward set invariance, and this work extends recent results on Boolean composition of nonsmooth barrier functions by explicitly addressing controlled systems, resulting in nonsmooth control barrier functions. The presented results permit a discontinuous controller, which is particularly amenable to control synthesis, and this paper develops an almost-active gradient for Boolean compositions of nonsmooth control barrier functions, which, when included as a constraint to a quadratic program, yields a valid controller. To verify these theoretical findings, the experimental results encode a series of constraints and synthesize a controller for a leader-follow team of mobile robots in real time.

Microservice architecture (MSA) is an emerging software architectural style, which differs fundamentally from the monolithic, layered architecture. MSA is based on microservices to provide several advantages, such as autonomy, composability, scalability, and fault-tolerance. However, how to manage complex "call" relationships between microservices is still a big issue that needs to be addressed. In this paper, we propose an approach for assisting the development of MSA-based systems, referred to as GMAT (Graph-based Microservice Analysis and Testing). GMAT can automatically generate "Service Dependency Graph (SDG)" to analyze and visualize the dependency relationships between microservices. Using GMAT, people are able to detect anomalies by analyzing risky service invocation chains in early stage of development, and trace the linkages between services when developing a new version of a target system. Experiments show that GMAT is able to work well for both small-scale and large-scale MSA-based systems.

The predictability of non-functional execution qualities is of utmost importance for the successful introduction of multi-core architectures in embedded systems requiring guarantees rather than best effort behavior. Due to the exclusive utilization of claimed resources, invasive computing provides isolation of applications on multi-core systems. This provides composability that allows to characterize and analyze individual applications statically and independent from others. In this paper, we demonstrate the principles of this resource-aware computing paradigm as an enabler for predictability of multiple non-functional properties, i.e., timing and reliability, applied to a cyber-physical system. In particular, we present the application and multi-processor implementation of a reliable and time-predictable acceleration of object detection algorithms for hard real-time control of an inverted pendulum.

The current interface provided by the C++17 parallel algorithms poses some limitations with respect to parallel data access and heterogeneous systems, such as personal computers and server nodes with GPUs, smartphones, and embedded System on a Chip chipsets. In this paper, we present a summary of why we believe the Ranges TS solves these problems, and also improves both programmability and performance on heterogeneous platforms.\ud \ud The complete paper has been submitted to WG21 for consideration, and here we present a summary of the changes proposed alongside new performance results.\ud \ud To the best of our knowledge, this is the first paper presented to WG21 that unifies the Ranges TS with the parallel algorithms introduced in C++17. Although there are various points of intersection, we will focus on the composability of functions, and the benefit that this brings to accelerator devices via kernel fusion.