Tree-based model remains state-of-the-art for many tasks involving tabular data. While these models are favored in resource-constrained environments, the inherent characteristics result in inefficiency during inference, posing significant challenges for conventional accelerators. Recent research has achieved unprecedented acceleration with content-addressable memory (CAM), yet at the cost of overwhelming memory consumption with low utilization, which is impractical for numerous real-world applications. This work addresses these issues by introducing an end-to-end framework RETENTION. RETENTION incorporates (1) a pruning algorithm to minimize model complexity under a user-specified accuracy loss tolerance, and (2) two data placement strategies to enhance memory utilization and further reduce capacity requirement. Experiment results show that space efficiency can be improved from 4.35× to 207.12× with less than 3% accuracy loss.

Security is a major challenge in swarm of drones. Network intrusion detection systems (IDS) are deployed to analyze and detect suspicious packet flows. Traditionally, they are implemented independently on each drone. However, due to heterogeneity and resource limitations of drones, IDS algorithms can fall short in satisfying Quality of Service (Qo$S$) metrics, such as latency and accuracy. We argue that a drone can make profit from the swarm by delegating part of the analysis of their packet flows to neighbor drones that have more processing power to enforce security. In this paper, we propose two solving methods to distribute the packet flows to analyze among drones in a way to ensure that it is processed with a minimum communication overhead to limit the attack surface, while ensuring Qo$S$metrics imposed by the drone mission. First, we propose a formulation of the distribution problem using both an Integer Linear Programming (ILP) and a Maximum-Flow Minimum-Cost (MFMC). Furthermore, we propose two specific solving methods for the distribution problem: (1) a Greedy Heuristic (GH), a non-exact solving method, but with small time overhead, and (2) an Adapted Edmonds-Karp (AEK) algorithm, an exact method, but with a higher time overhead. GH proved to be a very fast solution (up to more than 2000x faster than ILP with Branch and Bound), while AEK solution proved to find the exact solution even when the problem is very difficult.

Intrusion Detection Systems (IDS) are time-sensitive applications that aim to classify potentially malicious network traffic. IDSs are part of a class of applications that rely on short-lived functions that can be run reactively and, as such, could be deployed on edge resources, to offload processing from energy-constrained battery-backed devices. The serverless service model could fit the needs of such applications, given that the platform allows adequate levels of Quality of Service (QoS) for a variety of users, since the criticality of IDS applications depends on several parameters. Deploying serverless functions on unreserved edge resources requires to pay particular attention to (1) initialization delays that could be significant on low resources platforms, (2) inter-function communication between edge nodes, and (3) heterogeneous devices. In this paper, we propose both a storage-aware allocation and scheduling policy that seek to minimize task placement costs for service providers on edge devices while optimizing QoS for IDS users. To do so, we propose a caching and consolidation strategy that minimizes cold starts and inter-function communication delays while satisfying QoS by leveraging heterogeneous edge resources. We evaluated our platform in a simulation environment using characterization data from real-world IDS tasks and execution platforms and compared it with a vanilla Knative orchestrator and a storage-agnostic policy. Our strategy achieves 18% fewer QoS penalties while consolidating applications across 80% fewer edge nodes.

Drone swarms are increasingly being used to perform critical missions, such as inspection of ports and industrial installations. Each drone can embed heterogeneous execution platforms to successfully perform various computing tasks. As security threats may disrupt the progression of the drone mission, network intrusion detection systems (IDSs) are used. They analyze network traffic to detect malicious behaviors, but generally rely on resource-hungry machine learning models. To adapt to the dynamic nature of the mission, it is necessary to embed several IDS implementations leveraging heterogeneous computing resources of the drone and presenting a trade-off between security, throughput, and energy consumption. To address this issue, we propose, in this paper, an end-to-end flow composed of an offline phase to choose the IDS implementations to embed on the drone platform and an online phase to select the best implementation online considering the mission conditions at a given time. We devised a MILP formulation for the offline phase that proved to provide a 89.41% better Inverted Generational Distance (IGD) than a random choice. For the online phase, we investigated several solutions and designed a novel optimized strategy that proved to be around 16.76 times faster than TOPSIS while having comparable QoS metrics.

Swarms of drones are more and more used for critical missions and need to be protected against malicious users. Intrusion Detection Systems (IDS) are used to analyze network traffic in order to detect possible threats. Modern IDSs rely on machine learning models for such a sake. Because of the absence of central management in swarms of drones, IDSs constitute a good second-line protective measure. Investigating the execution of IDS (resource-hungry) algorithms on drone (resource-constrained) devices is crucial when it comes to optimizing energy, response time, memory footprint and algorithm precision. In addition, embedded platforms used in drones often incorporate heterogeneous computing platforms on which IDSs could be executed. In this paper, we present a methodology and results about characterizing the execution of different IDS models on various platform (CPUs, GPUs). In effect, as swarm of drones operate in different mission contexts (e.g. criticity level) and states (e.g. energy budget, memory footprint), it is important to explore which IDS model to run on which platforms for a given mission in a given context. For this sake, we evaluated several metrics on different platforms: energy and resource consumption, accuracy for malicious traffic detection and response time. The models tested (RF, CNN, DNN) have shown different performance according to the measured metrics and the chosen platform and proved to be relevant in different mission states.

With the surge in data production, Machine Learning techniques are now commonly used to build intelligent models. Traditionally, powerful platforms process data collected from endpoint devices. However, to address security threats and minimize communication traffic, models can be learned near endpoint devices, despite their resource shortage. K-means clustering is among the most common machine learning tasks used for embedded applications. Because the system is running on scarce resources, the learning process needs to obey a certain time limit. Even if current implementations of K-means have been optimized for embedded devices, they do not consider running within a predefined time budget. In this paper, we propose a deadline-aware and energy-efficient version of K-means called Embedded K-means (EK-means)11The source code is available on https://github.com/HafsaKaraAchira/EK-means-Embedded-K-means-.git, that relies on two main ideas: (1) smartly select the right subset of data to train on to meet the deadline at the expense of the smallest clustering error possible; (2) by dropping part of the data, slack times are identified and exploited opportunistically to apply Dynamic Voltage and Frequency Scaling techniques (DVFS) so as to decrease the energy consumption of the learning task. EK-means has been built on top of an I/O optimized version of K - means for embedded devices to maintain a low I/O proportion regardless of memory constraints. EK-means allows to cluster data while meeting more than 98% of the deadlines with a loss of 1.43 % of clustering quality, and an energy reduction of up to 84.26%.

Random forests is a widely used classification algorithm. It consists of a set of decision trees each of which is a classifier built on the basis of a random subset of the training data-set. In an environment where the memory work-space is low in comparison to the data-set size, when training a decision tree, a large proportion of the execution time is related to I/O operations. These are caused by data blocks transfers between the storage device and the memory work-space (in both directions). Our analysis of random forests training algorithms showed that there are two major issues :(1)Block Under-utilization: data blocks are poorly used when loaded into memory and have to be reloaded multiple times, meaning that the algorithm exhibits a poor spatial locality;(2)Data Over-read: the data-set is supposed to be fully loaded in memory whereas a large proportion of data are not effectively useful when building a decision tree. Our proposed solution is structured to address these two issues. First, we propose to reorganize the data-set in such a way to enhance spatial locality and second, to remove the assumption that the data-set is entirely loaded into memory and access data only when effectively needed. Our experiments show that this method made it possible to reduce random forest building time by 51 to 95% in comparison to a state-of-the-art method.

Machine Learning (ML) algorithms are increasingly used in embedded systems to perform different tasks such as clustering and pattern recognition. These algorithms are both compute and memory intensive whilst embedded devices offer lower hardware capabilities as compared to traditional ML platforms. K-means clustering is one of the widely used ML algorithms. In the case of large data-sets, our analysis showed that on average, more than 70% of the execution time is spent on I/Os. In this paper, we present a version of K-means that drastically reduces the number of I/Os by spanning the data-set only once as compared to the traditional version that reads it several times according to the number of iterations performed. Our evaluation showed that the proposed strategy reduces the overall execution time on large data-sets by 60% on average while lowering the number I/Os operations by 90% with a comparable precision to the traditional K-means implementation.