There are many concepts and algorithms in the study of real-time
systems. This project attempts to implement them to see their real
behaviors in a real machine making it easier to understand the
concepts and algorithms while allowing some real experimentations out
of curiosity to concretely see some problems like chained blocking in
priority inheritance and scheduling bug in a particular operating
system.

The codebase is divided logically into two parts:
1. Infrastructure components.
2. Experimentation components.

The first part contains software components that are used in
developing experimentation components. Each component should be in the
form of a single source file accompanied with a program to run test
cases that test the corresponding source file for semantical
correctness and the absent of memory leak and memory violations and
other things. As an example, the software component utility_time is
developed using C programming language and as such consists of
utility_time.h, utility_time.c (can be absent if all functions are
inlined) and utility_time_test.c. The test program is then registered
in the Makefile to be run with `make check'. The infrastructure
software components are usually developed by refactoring common
functions from the experimentation components. The infrastructure
software components and their Makefile are located in the base
directory.

The second part contains software components that are used to
understand some concepts, algorithms or problems related to the study
of real-time systems. Each experimentation software component should
be in the form of a single directory containing one README file
describing the concept(s) or algorithm(s) or problem(s) that the
component wishes to demonstrate, one or more source or data files, and
one Makefile. To create a new experimentation software component,
execute `make new_experiment EXP_NAME=DESIRED_EXPERIMENT_NAME'
replacing DESIRED_EXPERIMENT_NAME with the actual name of the new
experimentation component. Then, go to directory
"DESIRED_EXPERIMENT_NAME" and edit README describing the purpose of
the experiment. Afterwards, main.c and Makefile found in the directory
can be adjusted accordingly. The following files can be added to the
list of executables in Makefile to obtain the executables in the
experimentation directory:
cpu_hog_cbs

Usually an experimentation software component will produce some binary
log files that can be read using infrastructure software component
named read_task_stats_file.

The infrastructure component read_task_stats_file produces a GNU
Octave (Matlab-compatible) command to plot the cummulative
distribution of the task response times as the last line in its
output. The command will not be output if the task log file carries no
record of job execution statistics.

The infrastructure component sched_switch can be used to generate the
execution time line of a set of real-time tasks in the form of .vcd
file to be read and displayed by gtkwave from the output of ftrace
sched_switch plugin. Source: https://www.osadl.org/Single-View.111+M530bed48137.0.html?&tx_ttnews[month]=06&tx_ttnews[year]=2009

Each file defining main() function must also define two global
variables and initialize them appropriately as follows:
const char prog_name[] = "PROGRAM_NAME";
FILE *log_stream; /* Initialize this at the very beginning of main()
                   * so that the logging facility can work properly
                   */

The codebase is Free Software licensed under GNU GPL version 3 and is
developed to support the thesis work of Tadeus Prastowo in the area of
real-time systems.