Real-time operating systems (RTOS) are essential in fields where precision and timely response are critical, such as avionics, automotive, healthcare, and telecommunications. They ensure system determinism and predictability, guaranteeing the completion of tasks within strictly defined time frames. However, modern RTOS face several challenges. Achieving full determinism is complicated by potential hardware and software failures, as well as the complexity of synchronizing parallel processes. Efficient resource management is not always accomplished, which can lead to system overload and delays in task execution. This is particularly critical in high-load environments, where the volume of data and the number of tasks exceed the system's capabilities.
The flexibility and scalability of RTOS also remain challenges. Developing architectures that can easily adapt to new tasks and conditions without significant resource expenditure is necessary to maintain the relevance and effectiveness of systems in a rapidly changing technological environment [28].
The purpose of this study is to analyze the existing methods of clustering and load balancing in RTOS, to identify their advantages and disadvantages, as well as to pinpoint the main issues that need to be addressed. This will contribute to the development of new approaches and algorithms that will enhance the efficiency, reliability, and flexibility of real-time operating systems in missioncritical applications.
Clustering in real-time operating systems (RTOS) is a method of grouping data or objects based on similar characteristics or properties. Various methods are used in this field, each with its own advantages and disadvantages. The main categories include time-based methods, machine learning methods, genetic algorithms, and graph-based approaches. Each of these approaches offers unique solutions for clustering tasks and has specific areas of application.
Time Division Multiplexing (TDM) is used for efficient resource management in RTOS by allocating specific time intervals for different tasks [2,3,4]. This ensures predictable and regular access to resources, which is critically important for maintaining the properties of real-time systems [1].
In TDM, each task or group of tasks receives exclusive access to processor resources during a predefined time slot in a cyclic order. This approach supports high system performance and reliability by guaranteeing the regular execution of tasks [4].
It is a positive feature that each task is executed at a defined time, ensuring regular system operation. For example, in manufacturing processes, TDM can allocate fixed time slots to different sensors and mechanisms, preventing conflicts and ensuring seamless operation. The simplicity of implementing this method makes it easy to deploy and configure, which is crucial in embedded systems. Moreover, TDM promotes efficient resource usage through controlled time-slot allocation, optimizing their use. However, if a task does not use the entire allocated time slot, the unused resource is wasted, leading to inefficiency.
In systems with variable loads, fixed time intervals may be inefficient because they do not adapt to current needs [5,6]. Scalability also becomes an issue: in large systems with many tasks, it is difficult to provide sufficient time slots for each task. Optimizing resource usage is critical, and there arises a need for methods to dynamically redistribute unused resources among tasks. Considering task priorities is also important to ensure timely execution of critical tasks, especially in systems where this can affect safety or efficiency [7].
Machine Learning (ML) methods are increasingly applied for clustering and load balancing in RTOS due to their ability to automatically find optimal solutions and adapt to changing conditions [9,10]. They include clustering algorithms, reinforcement learning, and neural networks, which provide efficient resource allocation and task management in real-time. ML algorithms can automatically detect optimal patterns and solutions based on large datasets, aiding effective load distribution. They can dynamically change resource allocation strategies in response to system demands, ensuring optimal performance even under varying conditions. ML methods also help optimize resource use by predicting system load and dynamically adjusting resource distribution [11].
However, ML methods require large volumes of high-quality data for effective training, which can be challenging in many RTOS. The computational complexity of ML algorithms, especially neural networks, demands significant resources, which can be an issue for systems with limited capabilities. Implementing and tuning ML methods can be complex and require a high level of expertise [13,14]. The complexity of algorithms may hinder understanding and trust in their results, affecting their integration and monitoring in real systems.
Genetic Algorithms (GA), based on the principles of natural selection, are widely used to solve optimization problems, such as clustering and load balancing in RTOS [15]. They employ processes of selection, crossover, and mutation to find optimal or near-optimal solutions to complex problems. GAs can efficiently handle various types of tasks and resource constraints, finding global optima and adapting to different problems without significant changes to the algorithm [17]. They are also resilient to changes and uncertainties in the system, allowing stability and performance to be maintained under dynamic conditions. However, genetic algorithms have high computational complexity and require careful tuning of parameters, such as population size and crossover and mutation rates. Slow convergence can be an issue in real-time systems where timely decisions are critical. Scalability is also a concern because, as system size increases, computational requirements grow. Defining effective termination criteria and handling dynamic changes in the system remain challenges.
Graph-based methods use graph theory to model interactions between tasks and resources in RTOS. Tasks and resources are represented as graph nodes, and the connections between them as edges. This allows for effective task distribution and management using spectral clustering algorithms, minimum cut/maximum flow, and graph partitioning. These methods can model complex interactions and dependencies between tasks and resources, which contributes to more precise clustering and load balancing. They scale well and can work with large systems [19], which is essential for RTOS with numerous tasks. Flexibility in optimization allows these methods to be adapted to various goals, such as minimizing communication costs or evenly distributing the load. However, it is important to consider that these methods have high computational complexity, as building and processing large graphs require significant resources. This can be a problem for RTOS with limited capabilities and strict timing constraints.
The complexity of handling dynamic changes is also a challenge because these methods often assume a static graph structure. The need for accurate information on dependencies between tasks and resources can complicate their application in complex systems where such dependencies are not always clearly defined. Scalability remains an issue, as computational demands increase with system size and complexity. Developing more efficient algorithms and using parallel processing methods may help address these issues.
Thus, the analysis of existing clustering methods in RTOS shows that each has its advantages and disadvantages. The choice of the optimal method depends on the specific requirements of the system, its size, complexity, and resource constraints.
Further research is aimed at overcoming existing drawbacks and developing more efficient, adaptive, and scalable clustering methods for real-time operating systems [16,18]. This may include implementing hybrid approaches [20,21] that combine the advantages of different methods [22], and developing new algorithms that can work effectively in dynamic and complex RTOS environments, as well as monitoring security against viruses, such as with BOTNET [25,26,27].
To create a new architecture for real-time operating systems (RTOS), it is essential to conduct a thorough analysis of the limitations and shortcomings of existing clustering methods. Understanding why current approaches do not provide the desired efficiency, flexibility, and scalability is crucial. Based on this analysis, innovative solutions should be developed that combine the strengths of various methods and include mechanisms to counter malware [24].
The focus should be on developing new algorithms capable of effectively operating under dynamic real-time conditions. This may involve integrating the adaptability of machine learning with the efficiency of genetic algorithms and the ability of graph-based methods to model complex interactions. Such an approach would help overcome the limitations of each individual method, resulting in a more universal and effective solution.
It is important to optimize the computational complexity of new algorithms to ensure their operation under resource-constrained environments with strict timing requirements [23]. This can be achieved by utilizing parallel processing methods or developing lighter algorithms that do not require extensive computations.
Adaptation to dynamic changes within the system is critical. New approaches should include mechanisms that allow for rapid response to changes in load and resource availability, maintaining stable performance and reliability of the system in real-time. Additionally, addressing the issue of data availability and quality for training algorithms is essential.
In conclusion, creating a new architecture will require a comprehensive approach that combines innovative technologies, resource optimization, and a deep understanding of the specifics of realtime operating systems. This will enable the development of solutions that enhance the efficiency, flexibility, and reliability of such systems, meeting modern demands and challenges.
The architecture model of a task scheduler with intelligent clustering is based on the principle of collecting datasets that are sent to a separate system. This system analyzes the data and uses it to improve resource management efficiency in the future. The first step in developing a new approach is to collect data that includes information about tasks, resources, time parameters, and other important factors. This may involve metrics like task execution time, resource consumption, priorities, interdependencies between tasks, and other critical characteristics. Each task is linked to the corresponding parameters that reflect its requirements and behavior in the system.
Let ππ = {π₯π₯ 1 , π₯π₯ 2 , β¦ , π₯π₯ ππ } -be a set of tasks, and π π = {ππ 1 , ππ 2 , β¦ , ππ ππ } -be a set of resources. Each task π₯π₯ ππ β ππ is described by a set of characteristics πΉπΉ ππ = {ππ 1 , ππ 2 , β¦ , ππ ππ }, where ππ ππ represents one of the parameters, such as execution time, resource consumption, priorities, and interdependencies. Thus, data is collected to determine the set of features πΉπΉ ππ for each task π₯π₯ ππ , meaning each task is linked to a set of characteristics.:
where ππ ππ (π₯π₯ ππ ), -is the value of the j-th characteristic for problem π₯π₯ ππ .
For the correct functioning of machine learning algorithms, feature vectors πΉπΉ ππ are normalized. Let πΉπΉ οΏ½ ππ -be the normalized feature vector:
This brings all features to a common scale for further analysis.
From the set of all features πΉπΉ ππ , the most significant features ππ β πΉπΉ, which have the greatest impact on system performance, are selected. Let ππ = {π π 1 , π π 2 , β¦ , π π ππ }, where π π ππ -is a selected feature from the set πΉπΉ ππ , with ππ < ππ.
Tasks are clustered based on their features. Algorithms such as k-means or hierarchical clustering are used for this [8]. Clustering defines the function of task π₯π₯ ππ belonging to cluster πΆπΆ ππ :
where ππ(β ,β ) -is the distance between feature vectors, and ππ ππ -is the center of cluster πΆπΆ ππ .
After clustering, a machine learning model ππ is built and trained on clusters πΆπΆ 1 , πΆπΆ 2 , β¦ , πΆπΆ π‘π‘ . The model uses the feature values ππ to classify new tasks π₯π₯ ππππππ :
where π₯π₯ ππππππ -is a new task, and πΆπΆ ππ -is the cluster it belongs to.
The machine learning model predicts future resource needs based on the current system state. The prediction function ππ(π‘π‘)determines resource requirements at time π‘π‘:
where ππ ππ (π‘π‘) -is the predicted load on resource ππ ππ at time π‘π‘.
For optimal task distribution, a minimization function is used to reduce deviations between actual load ππ ππ πππππππ‘π‘ (π‘π‘) and predicted ππ ππ πππππ‘π‘ (π‘π‘):
This enables balanced load distribution and resource management, prioritizing the execution of the most critical tasks and improving the system's overall performance.
The model predicts future load and dynamically allocates tasks between processors or cores to achieve optimal balance. This helps prevent bottlenecks and ensures smooth system operation without failures.
In summary:
β’ The system collects data on tasks and resources in parallel with their execution in real time, without affecting its performance. β’ Data processing is offloaded to a separate module or service.
β’ Information analysis and machine learning model updates are performed periodically to keep the data current.
The results are used for decision-making regarding resource allocation and task scheduling in real-time mode.
To implement the prototype, it is proposed to use the FreeRTOS operating system with modified tasks.c and main.c files. In tasks.c, which is the main file for the FreeRTOS scheduler and contains task management functions, the vTaskSwitchContext() function is modified to call a custom method for task distribution. In main.c, code is added to create data collection tasks and call a custom scheduler, which will be implemented in a new file custom_scheduler.c. This file will define functions for data collection, task classification, and optimization of their distribution.
The algorithm consists of the following steps:
1. Data Collection in FreeRTOS: Data is collected by recording parameters during system operation or through simulation. Key parameters to be used in the model are defined, such as task type, resource usage (CPU), task execution time, and task priority. Based on this, a software model is created. Task execution in the system is simulated, with parameters being recorded during execution. This can be implemented using loops and timers to simulate real-time operation. The collected data is analyzed and transformed into the required format for further use in training machine learning models. Data is sent from the microcontroller via a configured HTTP client to an online server built on C# .NET 8, which receives this data. 2. Data Preparation for Modeling: Based on the collected data, a dataset is formed containing information about tasks, their characteristics, and time parameters. An external mathematical library, Math.NET Numerics, is used to process and prepare data for sending to the TinyML service. 3. Sending Data for Training: Using the .NET service, the data is converted into a format compatible with TinyML, sent for training, and a trained model is obtained. 4. Model Analysis and Prediction: After successful model training on the server, the next step is to use it for predictions. In this case, the model will be applied for prediction to optimize task distribution. 5. Sending Results to the Microcontroller: After performing predictions, the results are sent back to the microcontroller to update decision-making processes in the custom_scheduler.c file.
The data collection process will occur at intervals defined in constants and will automatically repeat.
FreeRTOS uses a time management principle through its task scheduler, which is very similar to Time Division Multiplexing (TDM). We can compare the results of default FreeRTOS and the results of FreeRTOS with the modified task scheduler.
To compare the efficiency of standard FreeRTOS and FreeRTOS with the modified architecture, several key metrics will be used:
β’ Task: This could be a data processing task, input/output, computational task, or simply a background task. β’ Resource Usage (CPU): Measurement of CPU usage during task execution.
β’ Task Execution Time: Measurement of the time required to complete a task.
First, we will run the program using the standard task scheduler and collect data on task execution time, resource usage, throughput, and latency through logging. After this, we will analyze the performance of the task scheduler in FreeRTOS with the modified architecture. For statistical purposes, we will set the number of tasks to 4. We will connect the DSView program, which typically works with the DS Logic logic analyzer.
Based on the results of the standard FreeRTOS task scheduler and the modified one (Figure 2, figure 3), several conclusions can be drawn.
Standard Scheduler:
β’ Tasks 1, 2, and 4 have equal priority, as seen from their even distribution on the graph. They run in parallel or take turns, but without clear prioritization. β’ Task 3 has high priority and is executed first after every interrupt generated by the system timer "tick". β’ The idle process does not run often because the processor is continuously occupied with task execution. Modified Scheduler:
β’ Priority-based task allocation: This graph shows that the modified scheduler implements task distribution based on their priority and execution time. There is a clear division of time between tasks. More controlled and structured use of CPU time is observed.
β’ Preemptive scheduling: Tasks are interrupted by other higher-priority tasks, demonstrating preemptive scheduler behavior where lower-priority tasks are paused to allow more important tasks to execute. β’ Idle process: The idle process now runs more actively when other tasks finish their execution time or are in a waiting state. This indicates that the system operates more efficiently as CPU power is used more evenly.
In the standard scheduler, resources are not fully optimized because tasks with equal priorities can interrupt each other, and the high-priority task completely occupies the CPU time.
In the modified scheduler, priority-based preemptive scheduling is clearly implemented, allowing the system to dynamically allocate task execution time and use CPU power more efficiently, enabling the system to respond faster to changes.
This work conducted a detailed analysis of existing clustering methods in real-time operating systems (RTOS), including time-based methods, machine learning methods, genetic algorithms, and graph-based approaches. It was found that each of these methods has its advantages and disadvantages, which limit their effectiveness, flexibility, and scalability in modern dynamic systems.
To overcome the identified limitations, intelligent clustering based on the use of machine learning methods on external modules was considered. This approach involves collecting and analyzing data on system tasks and resources, classifying tasks based on their characteristics, and optimizing resource allocation based on machine learning model predictions.
Experimental results show improved performance, including reduced CPU usage and decreased task execution time compared to the classic FreeRTOS scheduler.
Thus, intelligent clustering demonstrates the potential of using machine learning methods, and shifting the analysis logic to external modules for resource management and load balancing in realtime operating systems does not burden already limited resources.
Further research may focus on improving machine learning models, optimizing the computational complexity of algorithms, and adapting the system to dynamic changes and scaling for operation in more complex and demanding environments. Efforts to increase the efficiency of CPU time distribution are ongoing.
During the preparation of this work, the authors used Grammarly in order to: grammar and spelling check; DeepL Translate in order to: some phrases translation into English. After using these tools/services, the authors reviewed and edited the content as needed and take full responsibility for the publication's content.