Execution Overhead Research Articles

Energy-efficient triple modular redundancy scheduling on heterogeneous multi-core real-time systems

Triple modular redundancy (TMR) fault tolerance mechanism can provide almost perfect fault-masking, which has the great potential to enhance the reliability of real-time systems. However, multiple copies of a task are executed concurrently, which will lead to a sharp increase in system energy consumption. In this work, the problem of parallel applications using TMR on heterogeneous multi-core platforms to minimize energy consumption is studied. First, the heterogeneous earliest finish time algorithm is improved, and then according to the given application's deadline constraints and reliability requirements, an algorithm to extend the execution time of the copies is designed. Secondly, based on the properties of TMR, an algorithm for minimizing the execution overhead of the third copy (MEOTC) is designed. Finally, considering the actual situation of task execution, an online energy management (OEM) method is proposed. The proposed algorithms were compared with the state-of-the-art AFTSA algorithm, and the results show significant differences in energy consumption. Specifically, for light fault detection, the energy consumption of the MEOTC and OEM algorithms was found to be 80% and 72% respectively, compared with AFTSA. For heavy fault detection, the energy consumption of MEOTC and OEM was measured at 61% and 55% respectively, compared with AFTSA.

The computational and energy cost of simulation and storage for climate science: lessons from CMIP6

Abstract. The Coupled Model Intercomparison Project (CMIP) is one of the biggest international efforts aimed at better understanding the past, present, and future of climate changes in a multi-model context. A total of 21 model intercomparison projects (MIPs) were endorsed in its sixth phase (CMIP6), which included 190 different experiments that were used to simulate 40 000 years and produced around 40 PB of data in total. This paper presents the main findings obtained from the CPMIP (the Computational Performance Model Intercomparison Project), a collection of a common set of metrics, specifically designed for assessing climate model performance. These metrics were exclusively collected from the production runs of experiments used in CMIP6 and primarily from institutions within the IS-ENES3 consortium. The document presents the full set of CPMIP metrics per institution and experiment, including a detailed analysis and discussion of each of the measurements. During the analysis, we found a positive correlation between the core hours needed, the complexity of the models, and the resolution used. Likewise, we show that between 5 %–15 % of the execution cost is spent in the coupling between independent components, and it only gets worse by increasing the number of resources. From the data, it is clear that queue times have a great impact on the actual speed achieved and have a huge variability across different institutions, ranging from none to up to 78 % execution overhead. Furthermore, our evaluation shows that the estimated carbon footprint of running such big simulations within the IS-ENES3 consortium is 1692 t of CO2 equivalent. As a result of the collection, we contribute to the creation of a comprehensive database for future community reference, establishing a benchmark for evaluation and facilitating the multi-model, multi-platform comparisons crucial for understanding climate modelling performance. Given the diverse range of applications, configurations, and hardware utilised, further work is required for the standardisation and formulation of general rules. The paper concludes with recommendations for future exercises aimed at addressing the encountered challenges which will facilitate more collections of a similar nature.

Diciclo: Flexible User-level Services for Efficient Multitenant Isolation

Containers are a mainstream virtualization technique for running stateful workloads over persistent storage. In highly utilized multitenant hosts, resource contention at the system kernel leads to inefficient container input/output (I/O) handling. Although there are interesting techniques to address this issue, they incur high implementation complexity and execution overhead. As a cost-effective alternative, we introduce the Diciclo architecture with our assumptions, goals, and principles. For each tenant, Diciclo isolates the control and data I/O path at user level and runs dedicated storage systems. Diciclo includes the libservice unified user-level abstraction of system services and the node structure design pattern for the application and server side. We prototyped a toolkit of user-level components that comprise the library to invoke the standard I/O calls, the I/O communication mechanism, and the I/O services. Based on Diciclo, we built Danaus, a filesystem client that integrates a union filesystem with a Ceph distributed filesystem client and configurable shared cache. Across different host configurations, workloads, and systems, Danaus achieves improved performance stability, because it handles I/O with reserved per-tenant resources and avoids intensive kernel locking. Based on having built and evaluated Danaus, we share valuable lessons about resource contention, file management, service separation, and performance stability in multitenant systems.

Grammar-aware test case trimming for efficient hybrid fuzzing

In recent years, hybrid fuzzing has garnered significant attention by combining the benefits of both fuzzing and concolic execution. However, existing hybrid fuzzing techniques face problems such as the performance overhead of concolic execution and low code coverage in real-world programs. In this study, we observed that concolic execution often falls into repetitive loop structures when analyzing inputs generated by fuzzing, leading to the construction of redundant constraint expressions, which severely impacts its efficiency. Based on this observation, we design a test case trimming approach to remove input fields related to repetitive loop structures. We propose a lightweight taint analysis technique to infer input’s grammatical structure and construct a hierarchical grammar tree. Then, through delta debugging, we identify nodes that do not affect the code coverage and remove the corresponding input fields. We implement a prototype ScissorFuzz. Experimental results show that our approach brings an average of 8.2% improvement in code coverage and triggers 115 more crashes compared to the state-of-the-art hybrid fuzzing technique QSYM. By eliminating redundant fields, our approach reduces the resource and time overhead associated with concolic execution during input processing, thereby enhancing the efficiency of hybrid fuzzing.

Efficient task scheduling on the cloud using artificial neural network and particle swarm optimization

SummaryA difficult problem in the service‐oriented computing paradigm is improving task scheduler policy or resource provisioning.In order to increase the performance of cloud applications, this article primarily focuses on tasks for resource mapping policy optimization. With the aim of reducing makespan and execution overhead and increasing the average resource utilization, we suggested an efficient independent task scheduler employing supervised neural networks in this paper. The suggested ANN‐based scheduler uses the status of the cloud environment and incoming tasks as inputs to determine the optimal computing resource for a given assignment as a result that assembles our goal. We proposed a novel algorithm in this paper that uses a hybrid methodology based on a swarm intelligence algorithm (PSO) in combination with a machine learning technique (ANN). PSO is used to prepare the train and test dataset for the neural network. Results clearly state that suggested work achieves significant improvement to considered algorithms in makespan (45%–55%), average VM utilization (15%–20%), and execution overhead(20%–30%).

METSM: Multiobjective energy-efficient task scheduling model for an edge heterogeneous multiprocessor system

Along with the growth of computing requirements, edge devices, such as satellites and unmanned aerial vehicles, are equipped with heterogeneous multiprocessor systems to cope with complicated missions, including attitude control, signal processing, and objective detection. Concerning the extremely limited power on these devices, reducing the energy and time overhead of task execution evolves into a crucial challenge. Therefore, a multiobjective energy-efficient task scheduling technique (METSM) is proposed. First, a mathematical model is established for the energy-efficient task scheduling problem on edge heterogeneous multiprocessor systems. In this model, both makespan and total energy consumption are the optimization objectives. The decision variables include the task execution sequence, processor assignment, and dynamic voltage and frequency scaling level for each processor. Second, a problem-specific algorithm, namely, iterated greedy-based multiobjective optimizer (IMO), is proposed. Specifically, destruction–reconstruction and local search are redesigned for optimizing task scheduling and resource allocation. Considering local optima avoidance, a probabilistic mutation operation is developed. In addition, multiobjective-oriented strategies of optimal solution selection and acceptance criteria are adopted to accelerate the convergence. Finally, our proposed IMO is compared with several of the latest algorithms through multiple performance metrics. The experimental results show that IMO can obtain optimal Pareto fronts among several multiobjective methods. Savings of approximately 10% and 12% in time and power consumption, respectively, can be achieved by IMO. Moreover, in comparison with classic list-based heuristics for solving test cases, while IMO maintains a similar makespan, energy is reduced by nearly 90%.

Mutation testing optimisations using the Clang front‐end

AbstractMutation testing is the state‐of‐the‐art technique for assessing the fault detection capacity of a test suite. Unfortunately, a full mutation analysis is often prohibitively expensive. The CppCheck project for instance, demands a build time of 5.8 min and a test execution time of 17 s on our desktop computer. An unoptimised mutation analysis, for 55,000 generated mutants took 11.8 days in total, of which 4.3 days is spent on (re)compiling the project. In this paper, we present a feasibility study, investigating how a number of optimisation strategies can be implemented based on the Clang front‐end. These optimisation strategies allow to eliminate the compilation and execution overhead in order to support efficient mutation testing for the C language family. We provide a proof‐of‐concept tool that achieves a speedup of between 2 and 30 . We make a detailed analysis of the speedup induced by the optimisations, elaborate on the lessons learned and point out avenues for further improvements.

Testudo: Collaborative Intelligence for Latency-Critical Autonomous Systems

Edge computing is to be widely adopted for autonomous systems (AS) applications as compute-intensive processing tasks can be offloaded to compute-capable servers located at the edge of the network infrastructure. Given the critical nature of numerous AS applications, their tasks are mostly governed by strict execution deadlines to alleviate any safety concerns from delayed responses. Although wireless link uncertainty has prompted recent works to designate redundant local execution as an offloading fail-safe to ensure these deadlines are met, frequent invocation of such fail-safe mechanisms can potentially undermine the extent of performance gains from offloading. In this paper, we thoroughly analyze how redundant execution overheads can influence the overall performance. Then, we present Testudo, a methodology to optimize the energy consumption for latency-sensitive AS applications employing collaborative edge computing. Primarily, our methodology encompasses two main stages: (i) Designing processing pipelines supporting optimal offloading points and fail-safe integration using modular design techniques, and (ii) Developing a context-aware adaptive runtime solution based on Deep Reinforcement Learning to adapt the mode of operation according to the wireless network status. Our experiments for end-to-end control and object detection use-cases have shown that Testudo achieved energy gains reaching up to 31% and 13.4% (15.9% and 5.3% on average) for the former and latter, respectively, while incurring little-to-no degradation in prediction scores (<1% change) from state-of-the-art strategies.

BSEIFFS: Blockchain-secured edge-intelligent forest fire surveillance

This work aims to address two major issues in forest fire management: accurate real-time forecast and end-to-end secured data delivery between validated entities. To do so, we introduce BSEIFFS, a secured and intelligent forest fire prediction architecture realized through the convergence of Blockchain technology, mist computing, edge computing and machine learning paradigms. The proposed architecture renders Blockchain-backed security and Support Vector Regression based wildfire prediction at the edge by offloading the execution overheads to containerized cloud applications. Two algorithms namely Uncorrelated Data Transmission (UDT) algorithm and Blockchain based Audit Trail validation (BAT) algorithm are proposed to reduce number of repetitive packet transmissions and rendering a lightweight Blockchain based identity validation scheme at the edge respectively. The prediction model is trained using real-world meteorological data and tested on a steel manufacturing facility where controlled combustion and quenching processes closely resemble fire and rain scenarios. Apart from the Google Cloud Platform, tools such as IBM NodeRed, Siemens IBA PDA softwares are used to implement the BSEIFFS architecture. Extensive experimentation and comparative evaluation are performed with relevant baseline approaches. BSEIFFS achieves a prediction accuracy of 98.61%, ROC AUC score of 0.9668 with 0.1127 as false positive rate. The BSEIFFS SVR predictor with rbf kernel (MAE = 1.840, RMSE = 5.728) performs better than similar baseline approaches. The proposed UDT algorithm causes 82.02% reduction in packet transmissions through the network. BSEIFFS also achieves atleast 44.84% lesser energy consumption, 11.91% higher throughput and 71.91% lesser roundtrip time in comparison with baseline approaches. BSEIFFS can massively extend the benefits of the imminent B5G/6G technologies to perform fine-grained and faster computations.

AccHashtag : Accelerated Hashing for Detecting Fault-Injection Attacks on Embedded Neural Networks

We propose AccHashtag , the first framework for high-accuracy detection of fault-injection attacks on Deep Neural Networks (DNNs) with provable bounds on detection performance. Recent literature in fault-injection attacks shows the severe DNN accuracy degradation caused by bit flips. In this scenario, the attacker changes a few DNN weight bits during execution by injecting faults to the dynamic random-access memory (DRAM). To detect bit flips, AccHashtag extracts a unique signature from the benign DNN prior to deployment. The signature is used to validate the model’s integrity and verify the inference output on the fly. We propose a novel sensitivity analysis that identifies the most vulnerable DNN layers to the fault-injection attack. The DNN signature is constructed by encoding the weights in vulnerable layers using a low-collision hash function. During DNN inference, new hashes are extracted from the target layers and compared against the ground-truth signatures. AccHashtag incorporates a lightweight methodology that allows for real-time fault detection on embedded platforms. We devise a specialized compute core for AccHashtag on field-programmable gate arrays (FPGAs) to facilitate online hash generation in parallel to DNN execution. Extensive evaluations with the state-of-the-art bit-flip attack on various DNNs demonstrate the competitive advantage of AccHashtag in terms of both attack detection and execution overhead.

Aroc: An Automatic Repair Framework for On-Chain Smart Contracts

Ongoing smart contract attack events have seriously impeded the practical application of blockchain. Although lots of researches have been conducted, they mostly focus on off-chain vulnerability detection. However, smart contracts cannot be modified once they have been deployed on-chain, thus existing techniques cannot protect those deployed contracts from being attacked. To mitigate this problem, we propose a general smart contract repairer named Aroc, which can automatically patch vulnerable deployed contracts without changing the contract codes. The core insight of Aroc is to generate patch contracts to abort malicious transactions in advance. Taking the three most serious bug types (i.e., reentrancy, arithmetic bugs, and unchecked low-level checks) as examples, we present how Aroc automatically repairs them on-chain. We conduct abundant evaluations on four kinds of datasets to evaluate the effectiveness and efficiency of Aroc. In particular, Aroc can repair 95.95% of the vulnerable contracts with an average correctness ratio of 93.32%. Meanwhile, Aroc introduces acceptable additional overheads to smart contract users and blockchain miners. When compared with the state-of-the-art techniques, Aroc introduces either fewer execution overheads or contract codes.

Evaluation and Optimization of Distributed Machine Learning Techniques for Internet of Things

Federated learning (FL) and split learning (SL) are state-of-the-art distributed machine learning techniques to enable machine learning training without accessing raw data on clients or end devices. However, their comparative training performance under real-world resource-restricted Internet of Things (IoT) device settings remains barely studied. This work provides empirical comparisons of FL and SL in real-world IoT settings regarding (i) learning performance with heterogeneous data distributions and (ii) on-device execution overhead. Our analyses in this work demonstrate that the learning performance of SL is better than FL under an imbalanced data distribution but worse than FL under an extreme non-IID data distribution. Recently, FL and SL are combined to form splitfed learning (SFL) to leverage each of their benefits (e.g., parallel training of FL and lightweight on-device computation requirement of SL). Our work considers FL, SL, and SFL, and mounts them on Raspberry Pi devices to evaluate their performance, including training time, communication overhead, power consumption, and memory usage with resource-restricted IoT devices. Besides evaluations, we apply two optimizations. First, we generalize SFL by carefully examining the possibility of a hybrid type of model training at the server-side. The generalized SFL merges sequential (dependent) and parallel (independent) processes of model training and thus is beneficial to a system with a large scale of IoT devices, specifically at the server-side operations. Second, we propose pragmatic techniques to substantially reduce the communication overhead by up to four times for the SL and (generalized) SFL.

Task Scheduling Techniques for Energy Efficiency in the Cloud

Energy efficiency is a key goal in cloud datacentre since it saves money and complies with green computing standards. When energy efficiency is taken into account, task scheduling becomes much more complicated and crucial. Execution overhead and scalability are major concerns in current research on energy-efficient task scheduling. Machine learning has been widely utilized to solve the problem of energy-efficient task scheduling, however, it is usually used to anticipate resource usage rather than selecting the schedule. The bulk of machine learning approaches are used to anticipate resource consumption, and heuristic or metaheuristic algorithms utilize these predictions to choose which computer resource should be assigned to a certain activity. As per the knowledge and research, none of the algorithms have independently used machine learning to make an energy-efficient scheduling decision. Heuristic or meta-heuristic approaches, as well as approximation algorithms, are frequently used to solve NP-complete problems. In this paper, we discuss various studies that have been used to solve the problem of task scheduling which belongs to a class of NP-hard. We have proposed a model to achieve the objective of reduced energy consumption and CO2 emission in a cloud environment. In the future, the model shall be implemented in MATLAB and would be assessed on various parameters like makespan, execution time, resource utilization, QoS, Energy utilization, etc.

On Shielding Android’s Pending Intent from Malware Apps Using a Novel Ownership-Based Authentication

PendingIntent (PI) is an authority to use the sender’s permissions and identity by the receiver. Unprotected broadcast and PI s with an empty base intent are some of the vulnerable features that a malware utilizes to perform unauthorized access and privilege escalation (PE) attacks on the PI. To protect the PI from the above attacks, this paper proposes Sticky[Formula: see text]tent, an application-layer solution that uses ownership-based authentication to dynamically control the accessibility of the PI. Sticky[Formula: see text]tent is the first holistic work to use ownership-types to protect PI s from malware attacks. Some of the existing solutions follow static analysis of binary to identify the PI vulnerability. Through our empirical study using 23,922 apps, we found [Formula: see text]17% of PI-based vulnerabilities leads to unauthorized access and privilege escalation, which can be solved by using Sticky[Formula: see text]tent. We tested our model on the state-of-art applications and found an impressive harmonic mean (F1-score) value of 0.95–0.97 for intra and inter component analysis, which is 0.4–0.18 percentage more from the existing RAICC’s (a static analysis model instrumented with IccTA/Amandroid) result. As a proof-of-concept, we have taken a few real-world PI-based applications and replaced the PI with Sticky[Formula: see text]tent library. By comparing the result with RAICC, we can see that Sticky[Formula: see text]tent performs better in protecting PI dynamically from malware access. Though the proposed solution has an overhead of 0.005% per 5[Formula: see text]min application test, the end-user suffers only negligible execution overhead in the screen response and notification delays.

A Lightweight and Practical Anonymous Authentication Protocol Based on Bit-Self-Test PUF

Physical unclonable function (PUF), a cryptographic primitive, has recently been used in protocol design because it can ensure a tamper-evident feature. In many PUF-based protocol schemes, helper data algorithms (HDA) or fuzzy extractors (FE) are used to generate strong keys from unreliable PUF responses. However, these methods inevitably introduce complex error correction techniques, which not only increase the overhead of embedded devices but also pose some security risks. We propose a novel HDA technology, which does not use any high-overhead error correction mechanism, greatly reducing the implementation complexity and execution overhead. The novel HDA exploits the strategy of bit-self-test (BST) and the PUF can extract the robust responses by using the real-time generated reliable flags, and then an entropy extractor is used to generate the reliable and random key with high entropy. Based on this novel HDA, we design a lightweight anonymous authentication protocol. The protocol uses pseudo-random function (PRF) and XOR operation instead of the traditional hash function and symmetric encryption algorithm, which ensures security while reducing the overhead. Moreover, the proposed protocol does not require the server to store a large number of challenge–response pairs (CRPs), which reduces the storage overhead on the server while avoiding the risk of leakage of CRPs. Moreover, the device identity ID is updated during each round of the authentication process, which prevents the device from being tracked and protects the privacy of the device. The implementation and performance analysis of the protocol prototype on a Zynq-7000 SoC XC7Z010 FPGA shows that the proposed scheme solves the problems encountered with existing schemes and has additional security properties.

Timed Automaton-Based Quantitative Feasibility Analysis of Symmetric Cipher in Embedded RTOS: A Case Study of AES

The real-time operating system (RTOS) has a wide range of application domains and provides devices with the ability to schedule resources. Because of the restricted resources of embedded devices and the real-time constraints of RTOS, the application of cryptographic algorithms in these devices will affect the running systems. The existing approaches for RTOS ciphers’ evaluation are mainly provided by experimental data performance analysis, which, however, lack a clear judgment on the affected RTOS performance indicators, such as task schedulability, bandwidth, as well as a quantitative prediction of the remaining resources of RTOS. By focusing on task schedulability in RTOS, this paper provides a timed automaton-based quantitative approach to judge the feasibility of ciphers in embedded RTOS. First, a cryptographic algorithm execution overhead estimation model is established. Then, by combining the overhead model with a sensitivity analysis method, we can analyze the feasibility of the cryptographic algorithm. Finally, a task-oriented and timed automaton-based model is built to verify the analysis results. We take AES as a case study and carry out experiments on embedded devices. The experimental results show the effectiveness of our approach, which will provide specific feasibility indicators for the application of cryptographic algorithms in RTOS.

IoTCID: A Dynamic Detection Technology for Command Injection Vulnerabilities in IoT Devices

The pervasiveness of IoT devices has brought us convenience as well as the risks of security vulnerabilities. However, traditional device vulnerability detection methods cannot efficiently detect command injection vulnerabilities due to heavy execution overheads or false positives and false negatives. Therefore, we propose a novel dynamic detection solution, IoTCID. First, it generates constrained models by parsing the front-end files of the IoT device, and a static binary analysis is performed towards the back-end programs to locate the interface processing function. Then, it utilizes a fuzzing method based on the feedback from Distance Function, which selects high-quality samples through various scheduling strategies. Finally, with the help of the probe code, it compares the parameter of potential risk functions with samples to confirm the command injection vulnerabilities. We implement a prototype of IoTCID and evaluate it on real-world IoT devices from three vendors and confirm six vulnerabilities. It shows that IoTCID are effective in discovering command injection vulnerabilities in IoT devices.

On Android’s activity hijacking prevention

Android task and hijacking attacks can have a high impact on end users’ data confidentiality, since malicious applications exploiting such a threat can deceive end users and gain access to sensitive data silently. We believe that these threats are of high importance and thus in this paper we study them thoroughly through a tool capable to identify specific configurations that an application may be vulnerable. Furthermore, we propose an operating system level defense mechanism that controls the access to applications’ activities and is transparent to both end users and developers by leveraging on their built-in signatures. We demonstrate, through the tool that we have developed, different vulnerable configurations, while we evaluate the effectiveness of the proposed defense mechanism. Results have proved that the proposed solution does not affect Android’s task management and that end user suffer only negligible execution overhead.

Detection of Malicious Miner in Block chain Network

The block chain innovation has developed as an alluring answer for address execution and security issues in disseminated frameworks. Block chain’s open and dispersed friend topper record ability benefits distributed computing administrations which require capacities, for example, guaranteed information provenance, examining, the board of advanced resources, and disseminated agreement. Block chain’s fundamental agreement system permits to construct a carefully designed condition, where exchanges on any advanced resources are confirmed by set of genuine members or excavators. With utilization of solid cryptographic strategies, blocks of exchanges are binded together to empower permanence on the records. Not with standing, accomplishing agreement requests computational force from the diggers in return of attractive prize. Along these lines, eager diggers consistently attempt to abuse the framework by increasing their mining power. Right now, first talk about block chain’s capacity in giving guaranteed information provenance in cloud and present vulnerabilities in block chain cloud. Actualized at the mining pool chief, Silent Time stamping doesn’t require organizing nor any conduct or usage changes in the diggers; the absence of the execution overheads recognize Silent Time stamping from different plans which have been proposed yet had constrained achievement by and by. We break down the ideal assailant conduct against Silent Time stamping and the adequacy of Silent Time stamping against FAW assault. Quiet Time stamping adequately invalidates the prize addition of the FAW assault and lessens the ideal FAW aggressor technique to be either the problematic block-retaining assault (which never presents the retained block in the undermined pool and gives constrained motivators to a normal assailant) or legitimate mining.

Revisiting Test Impact Analysis in Continuous Testing From the Perspective of Code Dependencies

In continuous testing, developers execute automated test cases once or even several times per day to ensure the quality of the integrated code. Although continuous testing helps ensure the quality of the code and reduces maintenance effort, it also significantly increases test execution overhead. In this paper, we empirically evaluate the effectiveness of test impact analysis from the perspective of code dependencies in the continuous testing setting. We first applied test impact analysis to one year of software development history in 11 large-scale open-source systems. We found that even though the number of changed files is small in daily commits (median ranges from 3 to 28 files), around 50 percent or more of the test cases are still impacted and need to be executed. Motivated by our finding, we further studied the code dependencies between source code files and test cases, and among test cases. We found that 1) test cases often focus on testing the integrated behaviour of the systems and 15 percent of the test cases have dependencies with more than 20 source code files; 2) 18 percent of the test cases have dependencies with other test cases, and test case inheritance is the most common cause of test case dependencies; and 3) we documented four dependency-related test smells that we uncovered in our manual study. Our study provides the first step towards studying and understanding the effectiveness of test impact analysis in the continuous testing setting and provides insights on improving test design and execution.