Execution Platform Research Articles

Multi-Channel CNN based image classification using SKIP connection and MSVM

Deep learning innovations have paved way for effective classification algorithms using the Convolutional Neural Networks (CNNs). The current scenario uses very deep networks to improve the overall efficiency. This deep nature will result in increased complexity, a high number of parameters, increased execution time, and a more complex hardware platform for execution. Our research focuses on minimizing this complex nature of architecture. To achieve this, we employed the multi-channel CNN with a shallow layers approach, which consists of the main channel and side channels. The proposed work uses the Multi class Support Vector Machione (MSVM) as classifier and three distinct architectures with varied filter widths to acquire different performance characteristics. All these models are trained and tested on a brain tumor type database and performance parameters are compared to deep architectures like the Alexnet, VGG16, VGG19, and Resnet 50. When compared to deep architectures for the same database, our model can reduce the overall number of parameters and execution time with comparable accuracy. To improve the overall efficiency, our final architecture includes a skip connection.

Reuse in component-based prototyping: an industrial experience report from 15 years of reuse

At Thales Defense Mission Systems, software products first go through an industrial prototyping phase. We elaborate evolutionary prototypes which implement complete business behavior and fulfill functional requirements. We elaborate and evolve our solutions directly with end-users who act as stake-holders in the products’ design. Prototypes also serve as models for the final products development. Because software products in the defense industry are developed over many years, this prototyping phase is crucial. Therefore, reusing software is a high-stakes issue in our activities. Component-oriented development helps us to foster reuse throughout the life cycle of our products. The work presented in this paper stems from 15 years of experience in developing prototypes for the defense industry. We directly reuse component implementations to build new prototypes from existing ones. We reuse component interfaces transparently in multiple prototypes, whatever the underlying implementation solutions. This kind of reuse spans prototypes and final products which are deployed on different execution platforms. We reuse non-component legacy software that we integrate in our component architectures. In this case, we seamlessly augment standard classes with component behavior, while preserving legacy code. In this paper, we present our component programming framework with a focus on component reuse in the context of evolutionary prototyping. We study our prototypes composition through data we extracted from our code repository. On these last 15 years we observe that, in average, our prototypes are composed of 80% reused components. Today, some of our prototypes can be constituted of more than 96% reused components. In this context, we report three reuse scenarios we regularly encounter in our prototyping activity, and that motivates our engineering efforts toward reusable components.

Modular Model-Based Design for Aerial Manipulation with Simulink and ROS

Model-based design utilizing Simulink is state of the art in mechatronic system development. A key advantage is that developed control algorithms are deployed onto the target execution platform by automated code generation. For many robotic applications, the Robotic Operating System (ROS) is an attractive target execution platform with growing interest in UAV development such as aerial manipulation. The presented model-based design approach includes modular Guidance, Navigation and Control (GNC) development in Simulink and code generation of encapsulated ROS nodes for each of the GNC modules. To reduce control cycle latency, an automated code modification is proposed, for which design guidelines are given to define an efficient ROS node execution order. The modular approach is compared to a monolithic approach where just a single ROS node is generated for the complete GNC functionality. The design approach is demonstrated by flight experiments for an aerial screwing process where lateral contact forces at the manipulator tip are generated. Force estimation results compared to ground truth measurements show good agreement in flight experiment and simulation. For this case study, the modular design approach results in more than 73% time saving for code generation.

Achievements and Prospects of Artificial Intelligence Judicature in China

Artificial intelligence has affected and is changing our lives, penetrating into all fields of society, and the field of law is no exception. The development of artificial intelligence judicature such as smart court is a positive response of judicial informatization to artificial intelligence technology. Chinese judicature, which has experienced the development of electronization, networkization and digitization, has achieved significant transformation, integration and development in the era of artificial intelligence. At present, artificial intelligence has realized some applications in court system, procuratorate system and public security system, but these applications still remain at the superficial and uniformed level. With the improvement of artificial intelligence optical character recognition technology, natural language processing technology, intelligent speech recognition technology, element extraction technology and machine learning ability, higher-level artificial intelligence judicature urgently needs to be further promoted to run through the whole judicial process of the public security department, the Procuratorate department, the court department, and the Justice department. The data communication between the judicial systems with the data centers should adopt the optical one-way security isolation data automatic import system. The internal network between the judicial system adopts a two-way one-way gatekeeper to build a secure communication network. Based on the Secure network, interconnected and shared data storage, management and Protection platform, convenient transaction processing platform, intelligent legal analysis platform, efficient judicial execution platform, stable judicial supervision platform, extensive legal service platform should be established.

A Sound Level Meter featured with automatic estimation of the measurement uncertainty

In the area of measuring the environmental noise the equivalent sound pressure level LA,eq is adopted and compared with legal thresholds in order to characterize the site of interest. The paper describes an innovative Sound Level Meter (SLM) able to provide information about the measurand contribution to the measurement uncertainty estimation. This measurement technology is made possible thanks to an approach based on bootstrap method for selecting the suitable measurement episode for an estimation of LAeq. The firmware implementation of the developed SLM is disclosed with reference to a low-cost platform for real-time execution of the proposed methodology. Finally, a metrological characterization of the prototype performed in laboratory is reported as well as the performance comparison with a class 1 SLM in a real scenario. As a result, the smart features of the new SLM may be easily implemented by including commercial devices into the instrument schematics.

Optimization and Prediction Techniques for Self-Healing and Self-Learning Applications in a Trustworthy Cloud Continuum

The current IT market is more and more dominated by the “cloud continuum”. In the “traditional” cloud, computing resources are typically homogeneous in order to facilitate economies of scale. In contrast, in edge computing, computational resources are widely diverse, commonly with scarce capacities and must be managed very efficiently due to battery constraints or other limitations. A combination of resources and services at the edge (edge computing), in the core (cloud computing), and along the data path (fog computing) is needed through a trusted cloud continuum. This requires novel solutions for the creation, optimization, management, and automatic operation of such infrastructure through new approaches such as infrastructure as code (IaC). In this paper, we analyze how artificial intelligence (AI)-based techniques and tools can enhance the operation of complex applications to support the broad and multi-stage heterogeneity of the infrastructural layer in the “computing continuum” through the enhancement of IaC optimization, IaC self-learning, and IaC self-healing. To this extent, the presented work proposes a set of tools, methods, and techniques for applications’ operators to seamlessly select, combine, configure, and adapt computation resources all along the data path and support the complete service lifecycle covering: (1) optimized distributed application deployment over heterogeneous computing resources; (2) monitoring of execution platforms in real time including continuous control and trust of the infrastructural services; (3) application deployment and adaptation while optimizing the execution; and (4) application self-recovery to avoid compromising situations that may lead to an unexpected failure.

Off-chain management and state-tracking of smart programs on blockchain for secure and efficient decentralized computation

In the last decade various crypto-currencies opened new doors to a decentralized electronic monetary system. Emergence of new Blockchain platforms, such as Ethereum, introduced new features for the implementation of decentralized software or smart contracts. The applications of blockchain technology for secure and efficient information systems is rapidly increasing. However, due to the limitations of this platform including high computational and storage cost, it is not possible to run sophisticated and computationally expensive software on the blockchain. In this paper, a new framework for execution of smart programs on blockchain called the Smart Program Runner Framework (SPRF) is proposed. The proposed framework works by moving decentralized applications to the off-chain and only storing the hash of the state of the application on-chain. This framework can be implemented by creating a side-chain to an existing blockchain without any modifications. The proposed framework is implemented on Stellar blockchain and has various applications for secure and efficient information systems and can provide the required platform for execution of computationally demanding software on blockchain.

Deployment and communication patterns in microservice architectures: A systematic literature review

Context:Microservice is an architectural style that separates large systems into small functional units to provide better modularity. A key challenge of microservice architecture design frequently discussed in the literature is the identification and decomposition of the service modules. Besides this, two other key challenges can be identified, including the deployment of the modules on the corresponding execution platform, and adopted communication patterns. Objective:This study aims to identify and describe the reported deployment approaches, and the communication platforms for microservices in the current literature. Furthermore, we aim to describe the identified obstacles of these approaches as well as the corresponding research directions. Method:A systematic literature review (SLR) is conducted using a multiphase study selection process in which we reviewed a total of 239 papers. Among these, we selected 38 of them as primary studies related to the described research questions. Results:Based on our study, we could identify three types of deployment approaches and seven different communication patterns. Moreover, we have identified eight challenges related to the deployment and six challenges related to the communication concerns. Conclusion:Our study shows that in addition to the identification of modules, the deployment and communication approaches are equally crucial for a successful application of the microservice architecture style. Various deployment approaches and communication patterns appear to be useful for different contexts. The identified research directions in the literature study show that still more research is needed to cope with the current challenges.

Resource-constrained FPGA/DNN co-design

Deep neural networks (DNNs) have demonstrated super performance in most learning tasks. However, a DNN typically contains a large number of parameters and operations, requiring a high-end processing platform for high-speed execution. To address this challenge, hardware-and-software co-design strategies, which involve joint DNN optimization and hardware implementation, can be applied. These strategies reduce the parameters and operations of the DNN, and fit it into a low-resource processing platform. In this paper, a DNN model is used for the analysis of the data captured using an electrochemical method to determine the concentration of a neurotransmitter and the recoding electrode. Next, a DNN miniaturization algorithm is introduced, involving combined pruning and compression, to reduce the DNN resource utilization. Here, the DNN is transformed to have sparse parameters by pruning a percentage of its weights. The Lempel–Ziv–Welch algorithm is then applied to compress the sparse DNN. Next, a DNN overlay is developed, combining the decompression of the DNN parameters and DNN inference, to allow the execution of the DNN on a FPGA on the PYNQ-Z2 board. This approach helps avoid the need for inclusion of a complex quantization algorithm. It compresses the DNN by a factor of 6.18, leading to about 50% reduction in the resource utilization on the FPGA.

Network structure and pricing in the FX market

We construct the network, centrality measures, and attributions of trading profits for a sample of CLS Bank settlement data that spans diverse currency pairs, participants, and execution platforms. We define an average centrality differential as the return to the more-central counterparty in the trade. Estimates imply that the more-central counterparty receives a higher return, and that this differential increases as the counterparties’ centralities diverge. These two results are consistent with a pervasive centrality premium. This premium may reflect bargaining power, but we also find evidence that the premium is partially offset by losses that central agents incur in supplying liquidity.

Definition and validation of SNOMED CT subsets using the expression constraint language

BackgroundSNOMED CT Expression Constraint Language (ECL) is a declarative language developed by SNOMED International for the definition of SNOMED CT Expression Constraints (ECs). ECs are executable expressions that define intensional subsets of clinical meanings by stating constraints over the logic definition of concepts. The execution of an EC on some SNOMED CT substrate yields the intended subset, and it requires an execution engine able to receive an EC as input, execute it, and return the matching concepts. An important issue regarding subsets of clinical concepts is their use in terminology binding between clinical information models and terminologies for defining the set of valid values of codified data. ObjectiveTo define and implement methods for the simplification, semantic validation and execution of ECs over a graph-oriented SNOMED CT database, and to provide a method for the visual representation of subsets in order to explore, understand and validate its content, as well as to develop an EC execution platform, called SNQuery, which makes use of these methods. MethodsSince SNOMED CT is a directed and acyclic graph, we have used a graph-oriented database to represent the content of SNOMED CT, where the schema and instances are represented as graphs and the data manipulation is expressed by graph-oriented operations. For the execution of ECs over the graph database, it is performed a translation process in which ECs are translated into a set of Cypher Query Language queries. We have defined some EC simplification methods that leverage the logic structure underlying SNOMED CT. The purpose of these methods is to reduce the complexity of ECs and, in turn, its execution time, as well as to validate them from a SNOMED CT Concept Model and logical definition points of view. We also have developed a graphic representation based on the circle packing geometrical concept, which allows validating subsets, as well as pre-defined refsets and the terminology itself. ResultsWe have developed SNQuery, a platform for the definition of intensional subsets of SNOMED CT concepts by means of the execution of ECs over a graph-oriented SNOMED CT database. Additionally, we have incorporated methods for the simplification and semantic validation of ECs, as well as for the visualization of subsets as a mechanism to understand and validate them. SNQuery has been evaluated in terms of EC execution times. ConclusionIn this paper, we provide methods to simplify, semantically validate and execute ECs over a graph-oriented database. We also offer a method to visualize the intensional subsets obtained by executing ECs to explore, understand and validate them, as well as refsets and the terminology itself. The definition of intensional subsets is useful to bind content between clinical information models and clinical terminologies, which is a necessary step to achieve semantic interoperability between EHR systems.

Accelerated execution via eager-release of dependencies in task-based workflows

Task-based programming models offer a flexible way to express the unstructured parallelism patterns of nowadays complex applications. This expressive capability is required to achieve maximum possible performance for applications that are executed in distributed execution platforms. In current task-based workflows, tasks are launched for execution when their data dependencies are satisfied. However, even though the data dependencies of a certain task might have been already produced, the execution of this task will be delayed until its predecessor tasks completely finish their execution. As a consequence of this approach of releasing dependencies, the amount of parallelism inherent in applications is limited and performance improvement opportunities are wasted. To mitigate this limitation, we propose an eager approach for releasing data dependencies. Following this approach, the execution of tasks will not be delayed until their predecessor tasks completely finish their execution, instead, tasks will be launched for execution as soon as their data requirements are available. Hence, more parallelism is exposed and applications can achieve higher levels of performance by overlapping the execution of tasks. Towards achieving this goal, in this paper we propose applying two changes to task-based workflow systems. First, modifying the dependency relationships of tasks to be specified not only in terms of predecessor and successor tasks but also in terms of the data that caused these dependencies. Second, triggering the release of dependencies as soon as a predecessor task generates the output data instead of having to wait until the end of the predecessor execution to release all of its dependencies. We realize this proposal using PyCOMPSs: a task-based programming model for parallelizing Python applications. Our experiments show that using an eager approach for releasing dependencies achieves more than 50% performance improvement in the total execution time as compared to the default approach of releasing dependencies.

A workflow language for research e-infrastructures

Research e-infrastructures are “systems of systems,” patchworks of resources such as tools and services, which change over time to address the evolving needs of the scientific process. In such environments, researchers carry out their scientific process in terms of sequences of actions that mainly include invocation of web services, user interaction with web applications, user download and use of shared software libraries/tools. The resulting workflows are intended to generate new research products (articles, datasets, methods, etc.) out of existing ones. Sharing a digital and executable representation of such workflows with other scientists would enforce Open Science publishing principles of “reproducibility of science” and “transparent assessment of science.” This work presents HyWare, a language and execution platform capable of representing scientific processes in highly heterogeneous research e-infrastructures in terms of so-called hybrid workflows. Hybrid workflows can express sequences of “manually executable actions,” i.e., formal descriptions guiding users to repeat a reasoning, protocol or manual procedure, and “machine-executable actions,” i.e., encoding of the automated execution of one (or more) web services. An HyWare execution platform enables scientists to (i) create and share workflows out of a given action set (as defined by the users to match e-infrastructure needs) and (ii) execute hybrid workflows making sure input/output of the actions flow properly across manual and automated actions. The HyWare language and platform can be implemented as an extension of well-known workflow languages and platforms.

A proposed framework for cloud-aware multimodal multimedia big data analysis toward optimal resource allocation

Abstract The main goal of this paper is to demonstrate the structural design of Multimodal Multimedia Services in Cloud Platform (MMSCP). Thus, our proposed MMSCP architecture is built of three levels such as, Service Platform, Execution Platform and Structural platform. The functionality of service platform is to gather different forms of video files generated by the media creators and to store these files on the local platform. The second execution platform integrates both the Hadoop and Mapreduce functionalities. Finally, QoS based cloud computing functionalities (i.e. load balancing, security, resource allocation and network traffic management) is employed at the third structural platform. Likely, we introduced the Crow Search Algorithm (CSA) in structural platform for optimal allocation of resources. We adapt a Hadoop cluster to perform the experiment. Also, to conduct the resource allocation experiment we used some of the conventional optimization algorithms such as, ABC, GA and PSO for comparison with our proposed CSA algorithm imposed on the structural platform. However, to evaluate the performance of the algorithms we configured the CloudAnalyst tool. The simulation results illustrate that the proposed algorithm can allocate the virtual machine (VM) optimally to attain a minimal response time.

DeepFogSim: A Toolbox for Execution and Performance Evaluation of the Inference Phase of Conditional Deep Neural Networks with Early Exits Atop Distributed Fog Platforms

The recent introduction of the so-called Conditional Neural Networks (CDNNs) with multiple early exits, executed atop virtualized multi-tier Fog platforms, makes feasible the real-time and energy-efficient execution of analytics required by future Internet applications. However, until now, toolkits for the evaluation of energy-vs.-delay performance of the inference phase of CDNNs executed on such platforms, have not been available. Motivated by these considerations, in this contribution, we present DeepFogSim. It is a MATLAB-supported software toolbox aiming at testing the performance of virtualized technological platforms for the real-time distributed execution of the inference phase of CDNNs with early exits under IoT realms. The main peculiar features of the proposed DeepFogSim toolbox are that: (i) it allows the joint dynamic energy-aware optimization of the Fog-hosted computing-networking resources under hard constraints on the tolerated inference delays; (ii) it allows the repeatable and customizable simulation of the resulting energy-delay performance of the overall Fog execution platform; (iii) it allows the dynamic tracking of the performed resource allocation under time-varying operating conditions and/or failure events; and (iv) it is equipped with a user-friendly Graphic User Interface (GUI) that supports a number of graphic formats for data rendering. Some numerical results give evidence for about the actual capabilities of the proposed DeepFogSim toolbox.

The Case for a Best Execution Principle in Cross-border Payments

Cross-border payments suffer from a lack of speed and transparency and limited access, resulting in higher overall costs than domestic payments. This paper analyses how the best execution principle developed in the context of securities and derivatives could be applied to cross-border payments. Under that principle, financial institutions are legally required to provide the most advantageous order execution in terms of speed, risks and costs for their customers given the prevailing market environment. We argue that introducing best execution could alter the current set-up of cross-border payments which rests, for the most part, on a system of large, globally connected correspondent banks. The current system is best understood as one of “best friends”, in that the relationship among payment institutions determines through which institutions orders are routed. In turn, payment institutions charge their clients on a “cost plus profit” basis. Some of the payment institutions even benefit from rebates based on liquidity volume (kick-backs) and from reduced rates and soft commissions elsewhere in the payment chain. Overall, there is little incentive for payment institutions to truly put their clients first in terms of speed, costs and risks in the current “best friends” environment. Introducing “best execution” is potentially a game changer: it would require payment institutions to focus on their clients’ interests (i.e., when choosing the route the order is to take). Based on experience with the best execution principle enshrined in securities law, we would expect the large-scale introduction of digital routing systems to identify the offer that constitutes best execution. Furthermore, we expect that more links between correspondent banks, new service providers from the FinTech space, and public payment networks (including regional integration systems) would be established and would assist in identifying excess liquidity in infrequently traded currency pairs. While none of this requires distributed ledger technology, strictu sensu, one convenient way, technically, to achieve that purpose is by implementing a distributed ledger that functions, initially, as a digital liquidity marketplace (a pure information sharing device) and, which in time, could be further developed into a “best execution platform”.

Low-Cost Error Detection in Deep Neural Network Accelerators with Linear Algorithmic Checksums

The widespread adoption of deep neural networks in safety-critical systems necessitates the examination of the safety issues raised by hardware errors. The appropriateness of the concern is herein confirmed by evidencing the possible catastrophic impact of hardware bit errors on DNN accuracy. The consequent interest in fault tolerance methods that are comprehensive yet low-cost to match the margin requirements of consumer deep learning applications can be met through a rigorous exploration of the mathematical properties of the deep neural network computations. Our novel technique, Sanity-Check, allows error detection in fully-connected and convolutional layers through the use of linear algorithmic checksums. The purely software-based implementation of Sanity-Check facilitates the widespread adoption of our technique on a variety of off-the-shelf execution platforms while requiring no hardware modification. We further propose a dedicated hardware unit that seamlessly integrates with modern deep learning accelerators and eliminates the performance overhead of the software-based implementation at the cost of a negligible area and power budget in a DNN accelerator. Sanity-Check delivers perfect critical error coverage in our error injection experiments and offers a promising alternative for low-cost error detection in safety-critical deep neural network applications.

Programming at the edge of synchrony

Synchronization primitives for fault-tolerant distributed systems that ensure an effective and efficient cooperation among processes are an important challenge in the programming languages community. We present a new programming abstraction, ReSync, for implementing benign and Byzantine fault-tolerant protocols. ReSync has a new round structure that offers a simple abstraction for group communication, like it is customary in synchronous systems, but also allows messages to be received one by one, like in the asynchronous systems. This extension allows implementing network and algorithm-specific policies for the message reception, which is not possible in classic round models.The execution of ReSync programs is based on a new generic round switch protocol that generalizes the famous theoretical result about consensus in the presence of partial synchrony by of Dwork, Lynch, and Stockmeyer. We evaluate experimentally the performance of ReSync’s execution platform, by comparing consensus implementations in ReSync with LibPaxos3, etcd, and Bft-SMaRt, three consensus libraries tolerant to benign, resp. byzantine faults.

Continuous touch gesture recognition based on RNNs for capacitive proximity sensors

The use of capacitive sensors in the automotive context opens new possibilities in the development of new interfaces for machine interaction with the vehicle occupants. Large smart surfaces with gesture recognition will possibly be part of such new interfaces. However, the data processing cost of such new sensors should be maintained at a minimum while increasing the complexity of their gesture recognition accuracy by using modern deep-learning approaches. In this paper, we introduce the use of Bayesian optimization with execution platform constraints to implement accurate gesture recognition sensors based on 1D capacitive sensor arrays. Various RNN-based designs are implemented and optimized for their execution on embedded automotive microcontrollers. We show that LSTM and GRU-based designs are especially adequate achieving an average recall of the gesture classes over 95% in less than 100 optimization steps.

RANC: Reconfigurable Architecture for Neuromorphic Computing

Neuromorphic architectures have been introduced as platforms for energy efficient spiking neural network execution. The massive parallelism offered by these architectures has also triggered interest from non-machine learning application domains. In order to lift the barriers to entry for hardware designers and application developers we present RANC: a Reconfigurable Architecture for Neuromorphic Computing, an open-source highly flexible ecosystem that enables rapid experimentation with neuromorphic architectures in both software via C++ simulation and hardware via FPGA emulation. We present the utility of the RANC ecosystem by showing its ability to recreate behavior of the IBM's TrueNorth and validate with direct comparison to IBM's Compass simulation environment and published literature. RANC allows optimizing architectures based on application insights as well as prototyping future neuromorphic architectures that can support new classes of applications entirely. We demonstrate the highly parameterized and configurable nature of RANC by studying the impact of architectural changes on improving application mapping efficiency with quantitative analysis based on Alveo U250 FPGA. We present post routing resource usage and throughput analysis across implementations of Synthetic Aperture Radar classification and Vector Matrix Multiplication applications, and demonstrate a neuromorphic architecture that scales to emulating 259K distinct neurons and 73.3M distinct synapses.