Advances in autonomous vehicle (AV) technology promise substantial gains in safety and operational efficiency; nonetheless, frequent lane changes and merging maneuvers remain critical safety challenges that impede smooth traffic flow. This paper proposes the Minimizing Lane Change Algorithm (MLCA), a finite-state-machine controller that defers non-safety-critical lane changes to maintain lane stability. We evaluated MLCA through 100 microscopic traffic simulations on the SUMO platform, executed on an Intel Core i5-8250U processor. Compared to the LC2017 and MOBIL models, MLCA achieved a 35% reduction in lane-change events and a 28% decrease in collision occurrences across diverse traffic densities and roadway geometries. These findings confirm MLCA's efficacy on commodity hardware and its compatibility with existing AV control architectures. Future research will assess MLCA within high-fidelity CARLA environments and investigate GPU-accelerated, distributed simulation frameworks to support large-scale validation and real-time deployment.

The increasing adoption of electric vehicles demands advanced charging frameworks that ensure real-time safety, operational efficiency, and cost-effectiveness. This paper presents a dual-system architecture combining real-time safety monitoring with predictive scheduling for enhanced performance. The proposed system utilizes an adaptive protection mechanism that dynamically adjusts thresholds and implements a sophisticated tiered fault response strategy to safeguard charging operations for Level 1 and Level 2 chargers under varying conditions. Complementing this, a predictive model based on advanced Long Short-Term Memory networks leverages historical and real-time grid data to forecast optimal charging windows, significantly reducing electricity costs and grid stress. Secure data communication between the on-site controller and the cloud is facilitated through robust protocols, enabling seamless real-time monitoring and intelligent decision-making. Experimental results highlight the system's effectiveness, achieving over 95% fault detection accuracy, substantial cost savings of up to $ 0.05 per session, and ensuring scalability for diverse applications in residential and commercial environments. By integrating adaptive protection mechanisms with predictive scheduling models, the proposed framework addresses the inherent limitations of conventional static systems, offering a highly scalable, reliable, and economically efficient solution for modern electric vehicle charging infrastructure. This innovative approach sets a new standard by advancing safety, optimization, and sustainability, meeting the critical needs of current and future charging networks.

Test case prioritization (TCP) is essential for improving testing efficiency in large-scale continuous integration (CI) environments by reducing feedback time and efficient resource usage. Machine learning (ML) has shown promise in enhancing TCP, however, demonstrating its effectiveness in production environments remains a challenge. Using the IBM Open Liberty dataset, we developed and validated an ML-based TCP framework, showing how we identified the best-performing model step by step-from feature extraction and model training to hyperparameter tuning. After validating the framework in a research setting, we deployed it in IBM's live production system. The practical implications of this study are as follows. The production results closely mirrored the research outcomes, with models trained on recent data consistently outperforming older models and non-prioritized approaches. Specifically, prioritized builds achieved a mean Average Percentage of Faults Detected (APFD) value 50% higher than that of non-prioritized builds, leading to a substantial improvement in early fault detection. The consistent improvement of models trained on newer data (M-2023) over those trained on older data (M-2022) underscores the importance of regular model updates in maintaining optimal performance. This paper comprehensively compares research and production data, illustrating how our ML-driven TCP framework ensures optimal performance and detailing the steps necessary for successful implementation in dynamic CI environments.

Field-Programmable Gate Arrays (FPGAs) are increasingly used in critical applications and as versatile platforms for research, prototyping, and education. Their reprogrammable nature, however, makes them vulnerable to security threats, particularly through bitstream vulnerabilities. This paper presents a new approach for the real-time detection and mitigation of such vulnerabilities. We introduce BitVulLLM, a fine-tuned variant of LLAMA2 specifically used for FPGA bitstream vulnerability detection. As part of this research, we generated a comprehensive dataset of FPGA bitstreams, including secure and vulnerable configurations, to address the challenges of detecting and rectifying security flaws. Our method not only identifies vulnerabilities with high precision, but also generates secure bitstreams, significantly bolstering the security of embedded systems. This research represents a significant advancement in safeguarding FPGA applications and other use cases from cyber threats, improving the overall performance and reliability of embedded systems and hardware security.

Locks play a crucial role in multi-threaded applications, offering an effective solution for synchronizing shared resources. Yet, mishandling locks and threads can result in contention, leading to performance deterioration and compromising the scalability of software applications. In this study, several machine learning models were evaluated on how well they could detect the Java lock contention anti-pattern that caused the lock contention fault based on run time performance data. We trained the machine learning models with performance data generated from the execution of eight Java lock contention anti-patterns and tested the prediction of the models against 30% of the training data as well as performance data from six applications in the Dacappo benchmark that exhibit lock contention. Our results show that we can accurately identify the lock contention anti-pattern based on runtime performance data with an accuracy close to 90%.

Continuous integration pipelines execute extensive automated test suites to validate new software builds. In this fast-paced development environment, delivering timely testing results to developers is critical to ensuring software quality. Test case prioritization (TCP) emerges as a pivotal solution, enabling the prioritization of fault-prone test cases for immediate attention. Recent advancements in machine learning have showcased promising results in TCP, offering the potential to revolutionize how we optimize testing workflows. Hyperparameter tuning plays a crucial role in enhancing the performance of ML models. However, there needs to be more work investigating the effects of hyperparameter tuning on TCP. Therefore, we explore how optimized hyperparameters influence the performance of various ML classifiers, focusing on the Average Percentage of Faults Detected (APFD) metric. Through empirical analysis of ten real-world, large-scale, diverse datasets, we conduct a grid search-based tuning with 885 hyperparameter combinations for four machine learning models. Our results provide model-specific insights and demonstrate an average 15% improvement in model performance with hyperparameter tuning compared to default settings. We further explain how hyperparameter tuning improves precision (max = 1), recall (max = 0.9633), F1-score (max = 0.9662), and influences APFD value (max = 0.9835), indicating a direct connection between tuning and prioritization performance. Hence, this study underscores the importance of hyperparameter tuning in optimizing failure prediction models and their direct impact on prioritization performance.

Deep Neural Networks (DNNs) have gained widespread popularity in different domain applications due to their dominant performance. Despite the prevalence of massively parallel multi-core processor architectures, adopting large DNN models in embedded systems remains challenging, as most embedded applications are designed with single-core processors in mind. This limits DNN adoption in embedded systems due to inefficient leveraging of model parallelization and workload partitioning. Prior solutions attempt to address these challenges using data and model parallelism. However, they lack in finding optimal DNN model partitions and distributing them efficiently to achieve improved performance. This paper proposes a DNN model parallelism framework to accelerate model training by finding the optimal number of model partitions and resource provisions. The proposed framework combines data and model parallelism techniques to optimize the parallel processing of DNNs for embedded applications. In addition, it implements the pipeline execution of the partitioned models and integrates a task controller to manage the computing resources. The experimental results for image object detection demonstrate the applicability of our proposed framework in estimating the latest execution time and reducing overall model training time by almost 44.87% compared to the baseline AlexNet convolutional neural network (CNN) model.

Abstract The Internet of Things (IoT) has gained widespread importance in recent time. However, the related issues of security and privacy persist in such IoT networks. Owing to device limitations in terms of computational power and storage, standard protection approaches cannot be deployed. In this article, we propose a lightweight distributed intrusion detection system (IDS) framework, called FCAFE‐BNET (Fog based Context Aware Feature Extraction using BranchyNET). The proposed FCAFE‐BNET approach considers versatile network conditions, such as varying bandwidths and data loads, while allocating inference tasks to cloud/edge resources. FCAFE‐BNET is able to adjust to dynamic network conditions. This can be advantageous for applications with particular quality of service requirements, such as video streaming or real‐time communication, ensuring a steady and reliable performance. Early exit deep neural networks (DNNs) have been employed for faster inference generation at the edge. Often, the weights that the model learns in the initial layer may be sufficiently qualified to perform the required classification tasks. Instead of using subsequent layers of DNNs for generating the inference, we have employed the early‐exit mechanism in the DNNs. Such DNNs help to predict a wide range of testing samples through these early‐exit branches, upon crossing a threshold. This method maintains the confidence values corresponding to the inference. Employing this approach, we achieved a faster inference, with significantly high accuracy. Comparative studies exploit manual feature extraction techniques, that can potentially overlook certain valuable patterns, thus degrading classification performance. The proposed framework converts textual/tabular data into 2‐D images, allowing the DNN model to autonomously learns its own features. This conversion scheme facilitated the identification of various intrusion types, ranging from 5 to 14 different categories. FCAFE‐BNET works for both network‐based and host‐based IDS: NIDS and HIDS. Our experiments demonstrate that, in comparison with recent approaches, FCAFE‐BNET achieves a 39.12%–50.23% reduction in the total inference time on benchmark real‐world datasets, such as: NSL‐KDD, UNSW‐NB 15, ToN_IoT, and ADFA_LD.

The continuous Integration (CI) process runs a large set of automated test cases to verify software builds. The testing phase in the CI systems has timing constraints to ensure software quality without significantly delaying the CI builds. Therefore, CI requires efficient testing techniques such as Test Case Prioritization (TCP) to run faulty test cases with priority. Recent research studies on TCP utilize different Machine Learning (ML) methods to adopt the dynamic and complex nature of CI. However, the performance of ML for TCP may decrease for a low volume of data and less failure rate, whereas using existing data with similar patterns from other domains can be valuable. We formulate this as a transfer learning (TL) problem. TL has proven to be beneficial for many real-world applications where source domains have plenty of data, but the target domains have a scarcity of it. Therefore, this research investigates leveraging the benefit of transfer learning for test case prioritization (TCP). However, only some industrial CI datasets are publicly available due to data privacy protection regulations. In such cases, model-based transfer learning is a potential solution to share knowledge among different projects without revealing data to other stakeholders. This paper applies TransBoost, a tree-kernel-based TL algorithm, to evaluate the TL approach for 24 study subjects and identify potential source datasets.

Locks are essential in multi-threaded applications as they provide a solution to synchronization of shared resources. However, improper management of locks and threads can lead to contention and surface as run-time performance degradation in the application. Nowadays, performance engineers use legacy tools and their experience to determine causes of lock contention but it takes significant expertise to use these tools. In this paper, a data clustering approach is presented to help identify lock contention faults. The classifier is trained leveraging run-time performance data acquired from a catalog of lock contention Java anti-patterns and code smells. The K-means unsupervised classifier algorithm was used to create the classification model and the results show that lock contentions can be classified into three clusters that can be identified into those caused by a) threads spending too much time inside the critical section, b) threads blocked because of high frequency access requests, and c) threads with a low contention. This classifier is intended to be used to help tailor recommendations to the developer based on the lock contention anti-patterns and type of lock contention.

With the increasing demand for edge computing in cyber-physical system (CPS) applications, ensuring the safety and reliability of machine learning models running on edge devices during online model training and inference is essential. Although data and model parallelism offer significant advantages for large machine learning model training, adopting parallel computing architecture in edge networks is challenging. It introduces safety concerns while splitting and integrating machine learning models over different computing nodes, which can pose risks to the integrity and reliability of the system. Therefore, online model training and inference in edge networks require a safe parallel computing architecture to achieve improved performance with optimal resource utilization. To address this challenge, we propose an efficient machine learning model partitioning algorithm that considers the safety constraint and requirements of edge networks and includes the triple-modular redundancy (TMR) technique for trusted computation. Our proposed approach achieves a significant speedup of approximately 56.3% in net training time compared to the non-partitioning approach, making it more efficient and suitable for real-time applications in edge networks.

A real-time system is overloaded when all the tasks in a workload cannot meet their deadlines, and hence a robust algorithm is essential to maximize the number of tasks that meet their deadlines with the minimum number of miss rates and context switching. Although the Rate Monotonic (RM), Earliest Deadline First (EDF), and Least Laxity First (LLF) algorithms optimally perform and schedule tasks on a non-overloaded system, they have deficient performance when the system is overloaded. Therefore, we propose a new scheduling algorithm for uniprocessor and partitioned multiprocessor systems to address the overload situation. Since the proposed scheduling algorithm operates like EDF non-overloaded conditions, the proposed algorithm is optimal for non-overloaded systems. In addition, the proposed algorithm is robust against overloading situations as it executes the maximum possible tasks in the overload situation instead of missing deadlines of many tasks or burdening context switching to the system. The proposed algorithm allocates a processor to tasks based on the possibility of executing the task. The experimental results demonstrate that the proposed scheduling algorithm maximizes the number of tasks that meet their deadlines in overload conditions without a domino effect and context switching. In addition, the proposed algorithm achieves the lowest miss rate without context switching and the highest efficiency and processor utilization in the overloaded system compared with RM, EDF, and LLF.

This paper discusses the benefits of a distributed and collaborative approach for optimizing real-time intelligent systems with complex task scheduling requirements. We focus on the specific example of implementing car platoons in urban traffic, which requires efficient task mapping and scheduling to maximize efficiency and ensure optimal performance. To meet the demands of a car platoon environment, a collaborative task management system, EDFHC-ML, is proposed for connected autonomous vehicles using edge, fog, and cloud computing. We also evaluated our approach with three others and found that our method had the best performance in executing tasks within the deadline. Our proposed approach is beneficial for developing intelligent systems that require high-performance computing and real-time response.

The security of embedded systems is particularly crucial given the prevalence of embedded devices in daily life, business, and national defense. Firmware for embedded systems poses a serious threat to the safety of society, business, and the nation because of its robust concealment, difficulty in detection, and extended maintenance cycle. This technology is now an essential part of the contemporary experience, be it in the smart office, smart restaurant, smart home, or even the smart traffic system. Despite the fact that these systems are often fairly effective, the rapid expansion of embedded systems in smart cities have led to inconsistencies and misalignments between secured and unsecured systems, necessitating the development of secure, hacker-proof embedded systems. To solve this issue, we created a sizable, original, and objective dataset that is based on the latest Linux vulnerabilities for identifying the embedded system vulnerabilities and we modified a cutting-edge machine learning model for the Linux Kernel. The paper provides an updated EVDD and analysis of an extensive dataset for embedded system based vulnerability detection and also an updated state of the art deep learning model for embedded system vulnerability detection. We kept our dataset available for all researchers for future experiments and implementation.

Real-time embedded systems require sufficient re-sources to meet the application’s requirements. This often creates over-provisioning of resources, increasing the unused resources and overall costs. Determining optimal resource supply is essential to avoid over-resource provisioning. Existing research works lack consideration of finding the optimized supply of resources to meet the workload demand during any time intervals. Therefore, we propose a resource-aware optimization model to minimize the resource provision in any periodic task model. The proposed approach exploits the supply and demand bound functions to reduce resource over-provisioning while guaranteeing task deadlines. The preliminary experimental results show the benefits of our proposed approach for enhancing resource usage.

Jaywalking refers to pedestrians walking or crossing in a roadway that is not dedicated to pedestrians. Due to illegal jaywalking, every year a lot of accidents happen worldwide that cause a significant amount of death and other physical injuries. Real-time jaywalking detection and notification systems can contribute to protecting vulnerable road users and increasing road safety. Many computer vision-based image processing techniques have been proposed to detect jaywalking including deep learning, motion path analysis, motion object segmentation, trajectory forecasting and position localization. However, these techniques are designed and evaluated for a single road area and have limited notification capability. In this paper, we propose a real-time multi-object tracking approach for jaywalking detection and notification that can be applied in multiple road areas simultaneously. We use the state-of-the-art deep learning model YOLOv4 and the multi-object tracking algorithm DeepSORT for real-time object detection and tracking, respectively. The notification component incorporates a novel vehicle-region pair matching algorithm based on the proximity of vehicles to the monitored region. Performance evaluation shows that our proposed approach can effectively detect jaywalking with 100% accuracy and provide push notifications to nearby vehicles in real-time.

In the digital world where the smart device is a ubiquitous feature of modern life, embedded systems are almost everywhere. From the smart home, to the smart office, to the smart restaurant, and even the smart traffic system, this technology has become a crucial aspect of the modern experience. Although these systems are typically quite efficient, the rapid growth of embedded systems in smart cities has created inconsistencies and misalignments between secured and unsecured systems, which has created a need for secure, invulnerable embedded systems to protect modern users from the dangers of hacking. To address this problem, we have developed a large, novel, and unbiased dataset for embedded system vulnerability detection and modifying an advanced machine learning model for Linux Kernel. This unique dataset will provide the landscape of embedded systems with a multitude of ways to predict the vulnerabilities in the Linux Core and to detect all vulnerabilities during the development process. This research paper discusses the collection, filtering, correlation, and statistics associated with the dataset for Linux Embedded system.

With the rapid growth of Internet of Things (IoT) applications, the security of these systems has become critical. Fault injection attacks are a type of physical attack on the hardware components of an IoT system. These attacks cause the IoT system software to behave abnormally, which the adversaries exploit. Typically, these attacks have been detected through the use of a separate hardware detection mechanism, which is expensive and itself vulnerable to attack. The purpose of this paper is to propose a machine learning based approach to detect the attacks by monitoring specific run-time software parameters in the live environment of an IoT system. The proposed approach generates a labelled dataset by injecting instruction-level faults into the software executable, which is then used to train a machine learning model that can predict whether the IoT software system is currently being affected by a fault injection attack. Using a software fault injection tool to create a labelled dataset enables the use of supervised machine learning techniques, which produce more accurate prediction results than unsupervised techniques. The machine learning model can be used in the live environment of an IoT software system to monitor specific run-time software properties in order to detect the effects of a fault injection attack on the software. Additionally, the model classifies the type of fault introduced into the software as a result of the attack, which can be used to determine the necessary corrective action.

Model-checking and verification using Kripke structures and computational tree logic* (CTL*) use abstractions from the model/process/application to create the state-transition graphs that verify the model behavior. This scheme of profiling the performance of a process imports that the depth of the process operation correlates with the level abstraction. However, because of state explosion problems, these abstractions tend to restrict the scope to create manageable execution states. Therefore, for context modeling, this procedure does not generate a fine-grained behavioral model as generated states limit the ability of the abstraction to capture the execution time interactions amongst the processes, the hardware, and the kernel. Hence, in this paper, we present an end-to-end framework that comprises auto-encoders and probabilistic models to understand the behavior of system processes and detect deviant behaviors. We test this framework with a publicly available dataset generated from an autonomous aerial vehicle (UAV) application and the results show that by creating a fine-grained model that exploits previously unharnessed properties of the system calls, we can create a dynamic anomaly detection framework that evolves as the threats change.

Due to the significant communication delay to user tasks, the cloud is not ideal for executing real-time tasks with stringent deadlines. Fog computing consists of low computation capability fog nodes, or cloudlets located in proximity to the source of the data generation: the users. These cloudlets are ideal for executing tasks that have early deadlines. In this paper, we propose algorithms that schedule a set of real-time tasks on such an embedded-fog-cloud architecture. We consider hard, firm and soft tasks. The execution framework consists of embedded, fog and cloud processors. Tasks are scheduled on appropriate processors based on their deadline requirements. In general, hard real-time tasks are executed on embedded processors, firm real-time tasks on fog processors, and soft real-time tasks on cloud processors. We also propose a sufficient schedulability condition. Simulation results from the CERIT trace as well as test-bed results show that the proposed algorithms offer superior performance as compared to algorithms that do not employ fog processors. Employing an$Embedded-fog-cloud$architecture offers an improvement of 62.37 percent for real-time Success Ratio (SR) and 35 percent for Average Response Time as compared to scheduling tasks on the$cloud$alone.

Fog computing is a promising option for time sensitive vehicular over-the-air (OTA) updates, as it can offer enhanced network durability and lower communication delays, as compared to the cloud. Fog node utilization for updates is non-deterministic, largely owing to the patterns in vehicular traffic. The resultant over provisioning of resources manifests itself in increased communication and handover delays. Based on an analysis of the regional traffic pattern for a particular time period, our proposed algorithm determines the optimal number of fog nodes required for OTA updates. In order to pinpoint the traffic load and perform fog node distribution, we employ k-means clustering. The efficacy of our proposed approach is demonstrated using a case study that considers handover delay, propagation delay, transmission rate and vehicular mobility to predict the OTA update time. We employ a machine learning model for predicting the communication delay between fog devices and vehicles. Using the European WiFi hotspot signal strength NYC dataset and the 5G dataset, we observe that the proposed approach increases the net reserve fog resources by 26.57 percent on an average, and reduces the OTA update time by 5.34 percent. We test the scalability of the proposed approach by analyzing the performance in terms of average throughput while varying the number of vehicles and OTA update size. We observe that a system with less traffic and small update size overall delivers a higher average throughput of 46 Mbps versus one with more traffic and large update size overall, which provides an average throughput of 30 Mbps. The performance of the proposed OTA update scheme on simulations has been corroborated by implementation on a real-world testbed.

Energy efficiency considerations are required for resource reservations in real-time systems. However, current systems lack considerations of energy efficiency when calculating the optimum processor speed to ensure that the supply of resources is no less than the workload demand during any time intervals. Therefore, we propose an energy-aware optimization model using supply and demand bound functions to reduce over-provisioning resources while still guaranteeing task deadlines. Our initial experiment shows the advantages of using the proposed technique in terms of energy efficiency.

In the domain of autonomous vehicles, accurate modeling of the ever-changing dynamic environments is achieved using the DATMO (Detection And Tracking of Moving Objects) algorithm. This method uses input from various types of sensors and estimates their position and velocity using Kalman Filters with the integration of constant velocity model. Kalman Filters have increased in popularity as a part of robotics-related research in recent decades. The most promising applications of Kalman Filters can be seen in velocity estimation and robot localization. This paper proposes an implementation that uses point cloud data to predict the position and velocity of moving objects if and when they are detected. As demonstrated in the experimental results, the Kalman Filter accurately determines these quantities using noisy input point could data. We present a dynamic implementation, improved from a previously static implementation, for obstacle tracking. It can be helpful in automatic parking in vehicles and making decisions related to obstacle avoidance.

Current IoT applications generate huge volumes of complex data that requires agile analysis in order to obtain deep insights, often by applying Machine Learning (ML) techniques. Support vector machine (SVM) is one such ML technique that has been used in object detection, image classification, text categorization and Pattern Recognition. However, training even a simple SVM model on big data takes a significant amount of computational time. Due to this, the model is unable to react and adapt in real-time. There is an urgent need to speedup the training process. Since organizations typically use the cloud for this data processing, accelerating the training process has the advantage of bringing down costs. In this paper, we propose a model partitioning approach that partitions the tasks of Stochastic Gradient Descent based Support Vector Machines (SGD-SVM) on various edge devices for concurrent computation, thus reducing the training time significantly. The proposed partitioning mechanism not only brings down the training time but also maintains the approximate accuracy over the centralized cloud approach. With a goal of developing a smart objection detection system, we conduct experiments to evaluate the performance of the proposed method using SGD-SVM on an edge based architecture. The results illustrate that the proposed approach significantly reduces the training time by 47%, while decreasing the accuracy by 2%, and offering an optimal number of partitions.

With the expansion of the global mushroom industries, the prediction of future market demand and the production data is important for the further sales of mushroom. The mushroom industries usually receive dynamic demands which are highly non-seasonal and non-periodic in nature. As a result, it is a challenging task to ascertain future mushroom demand and production optimally. In a traditional approach, people produce a certain amount of mushroom in every season based on previous experiences that do not reflect the actual market demand. Therefore, in the case of the shortage of supply, most of the mushroom farms import the products from nearby farms or abroad. Alternatively, the surplus of products than demand is sold to the market at a cheaper rate before the products perish.This paper proposes a machine learning-based solution for the dynamic demand problem in mushroom farms. We have summarized the results obtained from three different machine learning models that are trained with the actual demands of the previous year's mushroom data. After that, we compare the test results given by each of the models to predict the future demand of mushrooms.

Despite reduced network latency and resilience, fog computing has not been leveraged for vehicular Over-the-Air (OTA) updates. Due to vehicle mobility and traffic, the resource utilization of fog nodes is almost non-deterministic, which increases the delay in communication and handover. In this paper, we propose an approach for distributing fog nodes by analyzing the vehicular traffic pattern in a region. The proposed method: (a) finds the optimal number of fog nodes for a specific time interval based on the traffic pattern of a region and (b) maximizes the net reserve resources enabling specific fog nodes. To do so, we use the k-means algorithm to identify traffic load and distribute the fog nodes using our proposed algorithm to maximize fog resource utilization. We present a case study of OTA updates that considers vehicle mobility, data transmission rate, propagation delay and handover delay to predict the required update time. The experimental results demonstrate that the proposed method of fog node allocation extends the net reserve resources by 30.92% on an average, and reduces the OTA update time.

This paper discusses the issue with scaling SIP/RTP services in a container orchestration cluster such as Kubernetes. In order to run SIP/RTP services in the Kubernetes platform, we require that state and affinity between the two ends, be maintained by the container orchestration cluster. Currently Kubernetes primarily supports stateless services like HTTP. The paper explains the challenge of the Kubernetes overlay network for SIP/RTP services by presenting four failure scenarios with the objective to validate the failure scenarios and present viable solutions. Two of the four failure scenarios have been validated and our approach to counter these failures are presented. One proposed solution is based on a SIP back-to-back user agent or proxy integrated with the Kubernetes environment and a second that leverages the Kubernetes Ingress architecture and services. A third probable solution discussed are the service meshes.

A transportation system is usually well-defined and operates based on a specific model defined during system design. However, the system can interact with different objects from its environment at runtime and needs to guarantee its functional and timing behavior even in the presence of adverse or failure situations through self-adaptation. Traditionally, techniques such as design analysis and testing are performed during the system design and development stage. During the adaptation process, the transportation system needs to provide assurance such that it is safe and schedulable. We present an adaptation framework, which guarantees the functional and timing behavior of the system in different situations by creating a knowledge base from mining the video stream of the monitored environment. The knowledge base provides information on system interactions with external objects, constraints imposed on the system due to interactions, and characterizes the runtime behavior. We guarantee the timing behavior by evaluating the constraints and their effects on the performance of the system. The experimental analysis of our work demonstrates that the situation-aware adaptation framework can significantly improve system performance by reducing scheduling overload and response time.

Containers are a method of virtualization. Advantages of containers include increasing utilization of bare-metal resources, and adding security isolation properties to various types of systems. These advantages make containers well-suited for applicable Internet-of-Things devices. This paper defines and describes our ‘kill switch’ Internet-of-Things container architecture pattern, aimed at enforcing multiple modes of application functionality. To our knowledge, this is a new and novel pattern that could lead to further research in the area. An example implementation that modifies the Docker engine, and an implementation using a Go script demonstrate that implementing the kill switch is feasible and achieves desired functionality.

This research seeks to prove that Deep Recurrent Q-Network (DRQN) approaches are great options for the control of autonomous vehicles. DRQN algorithms are widely used in video game competitions, but not many studies are available for their use in autonomous vehicles. In this paper, we present a context-based learning approach using DRQN for driverless vehicles. Our experiments demonstrate the effectiveness of using the DRQN algorithm over others.

One of the multiplier effects of the boom in mobile technologies ranging from cell phones to computers and wearables like smart watches is that every public and private common spaces are now dotted with Wi-Fi hotspots. These hotspots provide the convenience of accessing the internet on-the-go for either play or work. Also, with the increased automation of our daily routines by our mobile devices via a multitude of applications, our vulnerability to cyber fraud or attacks becomes higher too. Hence, the need for heightened security that is capable of detecting anomalies on-the-fly. However, these edge devices connected to the local area network come with diverse capabilities with varying degrees of limitations in compute and energy resources. Therefore, running a process-based anomaly detector is not given a high priority in these devices because; a) the primary functions of the applications running on the devices is not security; therefore, the device allocates much of its resources into satisfying the primary duty of the applications. b) the volume and velocity of the data are high. Therefore, in this paper, we introduce a multi-node (nodes and devices are used interchangeably in the paper) ad-hoc network that uses a novel offloading scheme to bring an online anomaly detection capability on the kernel events to the nodes in the network. We test the framework in a Wi-Fi-based ad-hoc network made up of several devices, and the results confirm our hypothesis that the scheme can reduce latency and increase the throughput of the anomaly detector, thereby making online anomaly detection in the edge possible without sacrificing the accuracy of the deep recurrent neural network.

The Internet of Things (IoT) and Machine Learning (ML) introduce embedded systems to many new roles and functions, but the current status quo of using these technologies together can be improved. The status quo has embedded systems offloading all of their ML functionality to an external device, but this can lead to unpredictable throughput due to network instability. We propose to run low-complexity ML models on the embedded system itself and distribute the workload when it has been measured to bypass a Worst-Case Execution Time (WCET) threshold.

In real-time systems, every task is characterized by its deadline where each task is expected to perform a function producing a correct result within a specified amount of time. A hard real-time system can lead to catastrophic failure if any task misses delivering the correct value at the right time. Although it is very important, most research works in real-time systems avoid discussion on the correctness of values at different points in time. Measurement units or instruments can be integrated with real-time systems to perform sensitive measurements where the measurement accuracy of a device is an essential factor for the precise result. Periodic inspections and calibrations of the measurement units validate the consistent measurement accuracy to ensure the safety of a system. In this paper, we present a software-based monitoring approach for the auto-calibration process that compares sporadically the accuracy of measurement units with the set of determined measurement standards such as National Institute of Standards and Technology (NIST) to ensure the correctness of the measurement instruments. This approach will automatically guide us to correct the measurement errors if the electronic devices are unable to perform with expected accuracy. To explain the applicability of our proposed strategy, we define different techniques considering the availability of the calibration standards and finally show an experiment of anomaly detection in a resistive voltage divider as a case study.

Real-time embedded system applications have become pervasive, and with the increasing reliance on automated systems for both critical and non-critical tasks, the trend is set to continue. This growing reliance on real-time embedded systems, as well as the rise in the complexity of these systems, demands an efficient monitoring tool that takes the complex interactions in the system into consideration. These systems are well-specified, and there exists standard error or fault detection mechanism to detect when an anomaly occurs in the applications controlling the operation. Nonetheless, these anomaly detection mechanisms gather information about the behavior of the software against its intended goals through the use of plausibility checks which rely on a priori knowledge of the application behavior. This kind of test raises two issues: (1) there should be a complete characterization of the software to derive the redundant information needed for plausibility checks, (2) this test focuses mainly on detecting errors/faults/anomalies in a single application with no regard to other entities in the integrated system. On the other hand, an embedded real-time system (fitted with an operating system) usually has the operating system and the integrated application statically linked to produce a single executable image. This bespoke nature of the embedded real-time system design means that the kernel traces reflect the behavior of the application and the associated hardware components at every point in time. Consequently, detecting deviations in the kernel trace invariably imply system-wide anomaly detection in the associated application and hardware. Thus, this paper targets anomaly not just in the application layer, but also in other layers that make up the real-time embedded system. Therefore, we introduce a hierarchical attention-based anomaly detection (HAbAD) model based on stacked Long Short-Term Memory (LSTM) Networks with Attention. It is a closed-world prediction-classification model which uses the reconstruction error from a non-parametric kernel density estimator to detect when an anomaly has occurred. We show the effectiveness of this approach using publicly available dataset, and the results confirm that this is a robust means of detecting anomalies in real-time embedded systems.

Software debugging, audit, and compliance testing are some of the tasks we perform using execution traces of an operating system. However, these actions gather information about the behavior of the software vis-a-vis its design aims. In this work, our analysis of the execution traces of an embedded real-time operating system (RTOS) is rather to model the behavior of the physical system being managed by the software application via the embedded operating system. Hence, for an event-triggered embedded RTOS that controls the behavior of a bespoke system like an unmanned aerial vehicle (UAV), the events in the execution traces of the embedded RTOS is directly linked to the operation of the controlled physical system. Therefore, we hypothesize that the frequency of events (method/function calls) per observation is a useful feature for modeling the behavior of the physical system controlled by the operating system.

Real-time applications are usually well-defined and operate based on a particular system model. However, in practical scenarios, the applications can perform differently because of the uncertainties in the environment. The system can use video streams to capture sequential real-time information of its surroundings. The system also needs to identify various constraints that have significant effects on its characteristics. Therefore, in this paper, we aim to monitor real-time applications and identify properties that can be used to analyze constraints such as performance or safety. By analyzing the constraints, we investigate the probability of failure as well as the performance of a system based on its behavior. An experimental analysis of a real-time traffic intersection monitoring demonstrates the applicability of our proposed approaches to extract useful information that can be used by a system to learn and adapt dynamic behaviors.

State consistency in safety-critical distributed systems is mandatory for synchronizing distributed decisions as found in dynamic time division multiple access (TDMA) schedules in the presence of faults. A dynamic TDMA schedule that supports multi-mode communication is sensitive to transient faults because stations can make incorrect local decisions at run time and cause state inconsistency. Faulty decisions are especially undesirable for safety-critical systems with hard real-time constraints. Therefore, real-time communication schedules must have the capability of detecting state inconsistency within a fixed amount of time. In this work, a reliable state consistency checking mechanism is proposed that uses history information for achieving superior goodput in comparison to the well-known controller state (C-State) based CRC approach and the two phase commit (2PC) protocol.

Multi-mode systems work in configurations, but face the challenge of ensuring timing guarantees during mode changes. In a multi-mode system, a mode-change request occurs when the system wants to operate in a new mode, but is already running in one. One mode may include some tasks that are same as that of another mode. Therefore, the new mode may have tasks that are same as the old mode. Changing modes in such a way to skip some already completed tasks can decrease the workload of the new mode. Traditional protocols for changing modes always look forward in time to schedule tasks, although using already completed tasks may avoid re-executing them in the new mode. Reusing common tasks reduces the time to re-execute them while switching modes. In this paper, we introduce the concept and design considerations for a mode-change technique that may use completed tasks stored in checkpoints to avoid unnecessary re-execution and facilitate faster execution of new mode tasks. Through an example case-study, experimental results demonstrate that the overhead of using checkpoints is low, and using rollback facilitates faster execution of new mode tasks if completed tasks stored in checkpoints can be reused.

Component-based design is important for the design of complex embedded software. By properly defining component interfaces, new components can be formed by composing existing components. A newly formed component may be further composed of other components. One of the key requirements for guaranteeing the compositionality of components in real-time systems is that the composite model must be consistent with, and indistinguishable from, the interface of a primitive component so that all real-time requirements are met. In addition to being used widely for schedulability analysis on different techniques such as earliest deadline first (EDF) and rate monotonic (RM), supply-demand functions have been applied to perform compositional schedulability analysis with periodic resource models. However, supply-demand function analysis for compositional schedules has only been done for hard real-time systems guarantees. This work analyzes overloads in embedded real-time control systems with soft deadlines and the analysis helps to build a compositional system that can tolerate delays. This paper also associates the schedulability analysis with a control application using a rapid prototype implementation.

With the growing demand in embedded systems, safety and non-safety critical parts are integrated together although guaranteeing safety is a hard problem to tackle due to the complexity of possible interactions between components involving communication. However, it is sufficiently recognized that separation of computation and communication can reduce the complexity of guaranteeing safety involved in interactions between components. In this work, we propose to use component interfaces derived from periodic resource supplies that can meet the demand of components experiencing bounded delays. The advantage of using interfaces is to provide minimal information of components without requiring the entire task specifications to generate a multi-mode communication schedule. We use integer linear programming to find assignments in generating schedules that are guaranteed to have low average mode-change delay. A video monitoring case study demonstrates the advantages on using our approach in generating communication schedules.

A key problem in designing multi-mode real-time systems is the generation of schedules to reduce the complexities of transforming the model semantics to code. Moreover, distributed multi-mode applications are prone to suffer from delays incurred during mode changes. We therefore aim to generate communication schedules that have low average mode-change delay for multi-mode real-time distributed applications. In this paper, we use optimization constraints associated to timing requirements to generate state-based schedules for multi-mode communication systems, and illustrate the workflow for generating schedules from specifications through a real-time video monitoring case-study. Our experiments in the case-study demonstrate that schedules generated using the proposed method reduce the average mode-change delay in relation to a randomized algorithm and the well-known EDF scheduling algorithm.

With the growth of complexity in the embedded domain, the use of distributed systems to support multiple realtime applications has become commonplace. These applications may share processor and network resources, and real-time scheduling policies can guarantee that these applications do not interfere with each other's ability to meet their temporal constraints. We believe that these applications should also be able to transparently share services and chains of services, without the coupling that such sharing typically implies. To solve this problem, we propose D-RES, a resource management system that guarantees temporal isolation between service-sharing applications in a distributed system. D-RES transparently tracks which application uses which service, billing the correct application even in case of nested service calls. We implemented D-RES, and demonstrate its ability to isolate service-sharing applications even in case of overload.

Real-time applications have deadline constraints. The system should provision sufficient resources for the application to meet the deadlines, and use supply and demand bound functions to analyze the schedulability of workloads. The concept of the demand bound function describes the upper bound on the resources required by the application, while the supply-bound function specifies the lower bound on the resources supplied to the tasks. If the system provides fewer resources than required, the application will experience an overload. Most work concentrates on designing systems that cannot experience short periods of overloads. This work explores resource provisioning for control applications that can tolerate overloads. It introduces analysis techniques for supply and demand bound functions that specifically consider overloads and delays in a periodic resource model. With this extended model, the work addresses three problems: (1) determine the worst-case delay for a given resource demand and supply under a periodic resource model, (2) find a periodic resource supply for a given workload and worst-case tolerable delay, and (3) for a control system with a given robustness criterion, identify a periodic resource supply with a worst-case delay.

Modern industrial networked control systems(NCSs) tend to be complicated and have dynamic workload by holding a variety of applications via a shared network. The static network scheduling algorithms fit most NCSs due to their deterministic characteristics and timing guarantees, but they cannot handle dynamic workloads for lack of making on the-fly decisions. The conditional state-based scheduling adds the dynamism in the static scheduling algorithms by automata or more explicitly state chart like formalisms with conditional transitions. In this paper, we propose CSS scheme that applies the conditional state-based scheduling to dynamically schedule different applications in the industrial NCSs. CSS aims at the time-triggered network in the NCSs and uses time division multiple access (TDMA) method to let the applications access the network. To enhance the scalability of the NCSs, we design CSS as a decentralized scheme where each application in NCSs has a local scheduler to make its schedule decisions. Appropriate algorithms are applied to ensure the scheduling decisions made by the local schedulers are consistent and the desired system performance can be achieved. Simulation results demonstrate the effectiveness of the proposed scheme compared to the static TDMA used in real-time networks.

State consistency in safety-critical distributed systems is mandatory for synchronizing distributed decisions as found in dynamic time division multiple access (TDMA) schedules in the presence of faults. A TDMA schedule that supports networked systems making decisions at run time is sensitive to transient faults, because stations can make incorrect local decisions at run time and cause state inconsistency and collisions. We refer to this type of TDMA schedule as a dynamic TDMA schedule. Faulty decisions are especially undesirable for safety-critical systems with hard real-time constraints. Hence, real-time communication schedules must have the capability of detecting state inconsistency within a fixed amount of time. In this paper, we show through experimentation that state inconsistency is a real problem, and we propose a solution for resolving state inconsistency in TDMA schedules.

We propose a technique to automatically synthesize programs and schedules for hard real-time distributed (embedded) systems from synchronous data-flow models. Our technique connects the SynDEx scheduling tool and the Network Code toolchain in a seamless flow of automatic model transformations that go all the way from specification to implementation.

Energy is one of the main obstacles to deploying wireless sensor networks (WSNs) because tiny sensor nodes cannot accommodate sufficient energy for achieving the desired level of usage. The clustering protocols of wireless sensor network attain the acme popularity among researchers because of effective usage clustering concepts based on locality and the election of a cluster head for each of them. We derive motivation from energy saving clustering schemes and propose an enhancement by saving energy and prolonging the lifetime of a sensor network significantly. The Low Energy Adaptive Clustering Hierarchy (LEACH) achieves popularity for its simplicity and applicability in WSNs. A large number of works exist that modify LEACH to strengthen the applicability of this scheme in practice, but only limited to the cluster set-up phase. In this paper, we observe a major problem that exists in all of the clustering protocols based on LEACH. That is, LEACH and its variants encounter premature death of cluster heads because data transmission time of each cycle of communication is fixed. Our proposed dynamic service policy-based scheme decreases the premature death of cluster heads and packet loss significantly.