## 4 Experiments  
In this section, we describe two experiments. The first experiment refers to the schedulability test, and the second refers to the infeasibility test. For the experiments, we develop a framework [31], which is written in SBCL [32], a dialect of the Common Lisp language. We use a laptop with Intel(R) Core(TM) i7-10510U CPU @ 1.80 GHz 2.30 GHz and RAM 16.0 GB. The first experiment compares our Algorithm 1 with state-of-the-art algorithms in this field. For our experiments, we chose algorithms developed for the same class of real-time systems as in our paper, namely non-preemptible tasks with the GFP scheduler. For our comparison, we selected the most successful algorithms for schedulability testing:LeeShin2014 from [6] and BaekLee2020 from [8]. Their higher performance compared to other similar algorithms [7; 25; 26; 27] is confirmed by the experiments presented in the corresponding sections of papers [6; 8]. We run experiments on all datasets for every mentioned algorithm and compare their performance with the performance of our algorithm. We refer to our algorithm and the compared algorithms as ALg1, LeeShin2014, and BaekLee2020, respectively. The experiment uses a dataset consisting of 40,000 task sets. Our experiments satisfy the following requirements:  
1. A period of every task in every set of the dataset is equal to its deadline: \(T_{i}=D_{i}\);
2. Every set of tasks in every set of the dataset is deadline-monotonic, i.e., tasks with a lower deadline have a higher priority;
3. The number of tasks is one more than the number of processors: \(n=m+1\). Here, Items 1 and 2 are the constraints that are used in [6; 8] to compare the LeeShin2014 and BaekLee2020 algorithms with previously developed algorithms. Item 3 is the specifics of our algorithm. We construct this dataset using the UUnifast algorithm [33; 34], which provides a uniform distribution of sets of tasks within a particular utilization. The paper [8] also takes this algorithm for the experiments. Then, we sort the UUnifast resulting sets of tasks by deadlines to ensure Item 2 of the requirements. The results of the experiment are shown in Tables 1 and 2 and in Figure 2, respectively. Table 1 and Figure 2(a) shows the total number of successful tests and their operation time. The algorithm operation time is measured in internal time units of the Lisp machine. The precise meaning of this quantity is implementation-defined; it may measure real time, run time, CPU cycles, or some other quantity. One internal time unit equals \(1/n\) of a second for some implementation-defined integer value of \(n\) specified in the variable internal-time-units-per-second. To show the distribution of successful schedulability tests on utilizations, schedulability indicators in Table 2 and Figure 2(b) are divided into five utilization classes, characterized by the representatives 0.2, 0.4, 0.6, 0.8, 1.0. The values of the columns with algorithm names contain the ratios of successful schedulability tests to the total number of tests (sets of tasks). Note that with the constraint \(n=m+1\), the algorithms LeeShin2014 and BaeKLee2020 showed the same result on this dataset (both in absolute and relative numbers). Also note that 0.0 for the 1.0 utilization class in the LeeShin2014 and BaeKLee2020 algorithms does not mean that these algorithms do not have successful tests. This only means that the number of such tests is negligible (in this particular case, 3 successful tests out of 3271 sets of tasks that fall into this class). It is also worth noting the small growth in the number of successful tests in class 1.0. This artifact is associated with a relatively small total number of tests in this class, due to the monotonization of the dataset. The second experiment illustrates the performance of our Algorithm 2 on a dataset also generated by the UUnifast algorithm [33]. To the best of our knowledge, there are no algorithms that perform the impossibility test. The only similar algorithm is the algorithm in [28].