xenial (1) rt-app.1.gz

NAME

       rt-app - Test application for simulating a real-time periodic load

SYNOPSIS

       rt-app <config-file>

       rt-app [options] -t <period>:<exec>[:policy[:CPU affinity[:prio[:deadline]]]] -t ...

INTRODUCTION

       rt-app  is  a  test  application  that  starts multiple periodic threads in order to simulate a real-time
       periodic load.  It supports SCHED_OTHER, SCHED_FIFO,  SCHED_RR  as  well  as  the  AQuoSA  framework  and
       SCHED_DEADLINE.

       Code is currently maintained on GitHub: https://github.com/gbagnoli/rt-app

REQUIREMENTS

       rt-app  runs  on GNU/Linux.  It needs autoconf, automake, libtool and a recent compiler (mainly: gcc) for
       basic features.  For advanced usage, the following optional libraries are needed: -  qreslib  for  AQuoSA
       support  (and,  obviously  a  GENS_SCHED  patched  kernel)  -  a SCHED_DEADLINE patched kernel to support
       SCHED_DEADLINE policy.  - json-c installed for reading config files.  In case libjson  is  not  available
       for your target, you can download and compile json-c from http://oss.metaparadigm.com/json-c/

USAGE

       rt-app  <config_file>  whereconfigfileisafull/relativepathtoajsonfile(lookunderdoc/for  an example config
       file) or "-" (without quotes) to read JSON data from stdin.

       The python merge script (/usr/share/doc/rt-app/examples/merge.py) can be used to  combine  json  snippets
       into   the  config  file:  e.g:  ./merge.py  -o  combined.json  global.json  resources.json  thread0.json
       thread1.json thread2.json thread3.json

       OR you can use commandline to define the taskset.

       Keep in mind that on commandline it will never be possible to define resources and how tasks access them.

       rt-app [options] -t <period>:<exec>[:cpu affinity[:policy[:deadline[:prio]]]]

       br POLICY: f=SCHED_FIFO, r=SCHED_RR, o=SCHED_OTHER,  q=AQuoSA  br  AFFINITY:  comma-separated  cpu  index
       (starting from 0) i.e. 0,2,3 for first, third and fourth CPU

       Note: when using AQuoSA scheduling, priority is used as percent increment for budget over exec time

OPTIONS

       -h, --help
              show this help

       -f, --fifo
              set default policy for threads to SCHED_FIFO

       -r, --rr
              set default policy fior threads to SCHED_RR

       -s, --spacing
              msec to wait beetween thread starts

       -l, --logdir
              save logs to different directory

       -b, --baselog
              basename for logs (implies -l . if not set)

       -G, --gnuplot
              generate gnuplot script (needs -l)

       -D, --duration
              time (in seconds) before stopping threads

       -K, --no-mlock
              Do not lock pages in memory

       -q, --qos
              create AQuoSA reservation

       -g, --frag
              fragment for the reservation

       --fifo,--rr,--qos
              sets  the  default  scheduling  policy for all threads. --qos is available only when compiled with
              AQuoSA support enabled.

       --logdir,--baselog
              control log output (rt-app creates one log for each thread).  If --logdir is not  present,  rt-app
              logs  everything  to  stdout.   When  logging  to  file and -D (see below) is present, the file is
              written at the end of execution, during which all logging data is kept in memory.

       --gnuplot
              if it is present then rt-app outputs sample gnuplot scripts to $logdir (which must be passed too

       --spacing,--duration
              control the spacing between threads and their duration of execution,  i.e. each thread is  started
              every $spacing ms and the total runtime is $duration.

       --frag (AQuoSA only)
              fragments  the  reservation  period  by  $fragmentation,  i.e.   reservation period is $frag times
              smaller than thread's period.

       --no-mlock
              do not lock threads' memory pages when using realtime scheduling classes

       Each thread is specified by

       --thread <period>:<exec>[:$POLICY[:deadline[:prio]]]:

       period : thread period in microseconds

       exec   : thread WCET in microseconds

       policy : one of f=SCHED_FIFO, r=SCHED_RR, o=SCHED_OTHER, q=AQuoSA (if enabled)

       affinity
              : comma-separated cpu index (starting from 0) i.e. 0,2,3 for first, third and fourth CPU

       prio   : thread priority in SCHED_FIFO/SCHED_RR/SCHED_OTHER, percentile increment for AQuoSA  reservation
              budget w.r.t. WCET.

       deadline
              : deadline in microseconds (used ONLY for plotting!)