Test tool budget enforcement methods.

2 files changed, 263 insertions, 4 deletions

diff --git a/Makefile b/Makefile
index 3489de6..a8e528e 100644
--- a/Makefile
+++ b/Makefile
@@ -20,6 +20,7 @@ LITMUS_KERNEL ?= ../litmus-rt
 
 # compiler flags
 flags-debug    = -O2 -Wall -Werror -g -Wdeclaration-after-statement
+flags-debug-cpp    = -O2 -Wall -Werror -g
 flags-api      = -D_XOPEN_SOURCE=600 -D_GNU_SOURCE
 flags-misc     = -fasynchronous-unwind-tables -fnon-call-exceptions
 
@@ -49,7 +50,7 @@ LIBLITMUS ?= .
 headers = -I${LIBLITMUS}/include -I${LIBLITMUS}/arch/${include-${ARCH}}/include
 
 # combine options
-CPPFLAGS = ${flags-api} ${flags-misc} ${flags-${ARCH}} -DARCH=${ARCH} ${headers}
+CPPFLAGS = ${flags-api} ${flags-debug-cpp} ${flags-misc} ${flags-${ARCH}} -DARCH=${ARCH} ${headers}
 CFLAGS   = ${flags-debug} ${flags-misc}
 LDFLAGS  = ${flags-${ARCH}}
 
@@ -62,18 +63,24 @@ ifeq (${CC},cc)
 CC = gcc
 endif
 
+#ifeq (${CPP},cpp)
+CPP = g++
+#endif
+
 # incorporate cross-compiler (if any)
 CC  := ${CROSS_COMPILE}${CC}
+CPP  := ${CROSS_COMPILE}${CPP}
 LD  := ${CROSS_COMPILE}${LD}
 AR  := ${CROSS_COMPILE}${AR}
 
 # ##############################################################################
 # Targets
 
-all     = lib ${rt-apps}
+all     = lib ${rt-apps} ${rt-cppapps}
 rt-apps = cycles base_task rt_launch rtspin release_ts measure_syscall \
           base_mt_task uncache runtests \
           nested locktest ikglptest dgl aux_threads normal_task
+rt-cppapps = budget
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
 
@@ -118,6 +125,7 @@ help:
 
 clean:
         rm -f ${rt-apps}
+        rm -f ${rt-cppapps}
         rm -f *.o *.d *.a test_catalog.inc
         rm -f ${imported-headers}
         rm -f inc/config.makefile
@@ -179,8 +187,7 @@ lib: liblitmus.a
 
 # all .c file in src/ are linked into liblitmus
 vpath %.c src/
-vpath %.c gpu/
-obj-lib = $(patsubst src/%.c,%.o,$(wildcard src/*.c)) $(patsubst gpu/%.c,%.o,$(wildcard gpu/*.c))
+obj-lib = $(patsubst src/%.c,%.o,$(wildcard src/*.c))
 
 liblitmus.a: ${obj-lib}
         ${AR} rcs $@ $+
@@ -246,6 +253,12 @@ obj-release_ts = release_ts.o
 obj-measure_syscall = null_call.o
 lib-measure_syscall = -lm
 
+
+vpath %.cpp gpu/
+
+objcpp-budget = budget.o common.o
+lib-budget = -lrt -lm -pthread
+
 # ##############################################################################
 # Build everything that depends on liblitmus.
 
@@ -253,12 +266,17 @@ lib-measure_syscall = -lm
 ${rt-apps}: $${obj-$$@} liblitmus.a
         $(CC) -o $@ $(LDFLAGS) ${ldf-$@} $(filter-out liblitmus.a,$+) $(LOADLIBS) $(LDLIBS) ${liblitmus-flags} ${lib-$@}
 
+${rt-cppapps}: $${objcpp-$$@} liblitmus.a
+        $(CPP) -o $@ $(LDFLAGS) ${ldf-$@} $(filter-out liblitmus.a,$+) $(LOADLIBS) $(LDLIBS) ${liblitmus-flags} ${lib-$@}
+
 # ##############################################################################
 # Dependency resolution.
 
 vpath %.c bin/ src/ gpu/ tests/
+vpath %.cpp gpu/
 
 obj-all = ${sort ${foreach target,${all},${obj-${target}}}}
+obj-all += ${sort ${foreach target,${all},${objcpp-${target}}}}
 
 # rule to generate dependency files
 %.d: %.c ${imported-headers}
@@ -267,6 +285,12 @@ obj-all = ${sort ${foreach target,${all},${obj-${target}}}}
                 sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
                 rm -f $@.$$$$
 
+%.d: %.cpp ${imported-headers}
+        @set -e; rm -f $@; \
+                $(CPP) -MM $(CPPFLAGS) $< > $@.$$$$; \
+                sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
+                rm -f $@.$$$$
+
 ifeq ($(MAKECMDGOALS),)
 MAKECMDGOALS += all
 endif
diff --git a/gpu/budget.cpp b/gpu/budget.cpp
new file mode 100644
index 0000000..f62c515
--- /dev/null
+++ b/gpu/budget.cpp
@@ -0,0 +1,235 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <math.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+/* Include gettid() */
+#include <sys/types.h>
+
+/* Include threading support. */
+#include <pthread.h>
+
+/* Include the LITMUS^RT API.*/
+#include "litmus.h"
+
+#define NUMS 4096
+static int nums[NUMS];
+
+inline static lt_t cputime_ns(void)
+{
+        struct timespec ts;
+        lt_t time;
+        clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
+
+        // safe, as long as sizeof(ls_t) >= 8
+        time = s2ns(ts.tv_sec) + ts.tv_nsec;
+
+        return time;
+}
+
+inline static lt_t wtime_ns(void)
+{
+        struct timespec ts;
+        lt_t time;
+        clock_gettime(CLOCK_MONOTONIC, &ts);
+
+        // safe, as long as sizeof(ls_t) >= 8
+        time = s2ns(ts.tv_sec) + ts.tv_nsec;
+
+        return time;
+}
+
+static int loop_once(void)
+{
+        int i, j = 0;
+        for (i = 0; i < NUMS; ++i)
+                j += nums[i]++;
+        return j;
+}
+
+int loop_for(lt_t time)
+{
+        lt_t end, now;
+        lt_t last_loop = 0, loop_start;
+        int dummy = 0;
+
+        last_loop = 0;
+
+        now = cputime_ns();
+        end = now + time;
+
+        /* '+ last_loop' attempts to avoid overrun */
+        while (now + last_loop < end) {
+                loop_start = now;
+                dummy += loop_once();
+                now = cputime_ns();
+                last_loop = now - loop_start;
+        }
+
+        return dummy;
+}
+
+int OVERRUN = 0;
+int SIGNALS = 0;
+int BLOCK_SIGNALS_ON_SLEEP = 0;
+int OVERRUN_RATE = 1; /* default: every job overruns */
+
+int NUM_JOBS = 0;
+int NUM_COMPLETED_JOBS = 0;
+int NUM_OVERRUNS = 0;
+
+lt_t overrun_extra = 0;
+
+int job(lt_t exec_ns, lt_t budget_ns)
+{
+        ++NUM_JOBS;
+
+        try{
+                lt_t approx_remaining = budget_ns;
+                lt_t now = cputime_ns();
+                loop_for(lt_t(exec_ns * 0.9)); /* fudge it a bit to account for overheads */
+
+                if (OVERRUN) {
+                        // do we want to overrun this job?
+                        if ((NUM_JOBS % OVERRUN_RATE) == 0) {
+                                approx_remaining -= (cputime_ns() - now);
+
+                                if (SIGNALS && BLOCK_SIGNALS_ON_SLEEP)
+                                        block_litmus_signals(SIG_BUDGET);
+
+                                // intentionally overrun via suspension
+                                lt_sleep(approx_remaining + overrun_extra);
+
+                                if (SIGNALS && BLOCK_SIGNALS_ON_SLEEP)
+                                        unblock_litmus_signals(SIG_BUDGET);
+                        }
+                }
+                ++NUM_COMPLETED_JOBS;
+        }
+        catch (const litmus::sigbudget& e) {
+                ++NUM_OVERRUNS;
+        }
+
+        sleep_next_period();
+        return 1;
+}
+
+#define OPTSTR "sboOva"
+
+int main(int argc, char** argv)
+{
+        int ret;
+        lt_t e_ns = ms2ns(10);
+        lt_t p_ns = ms2ns(100);
+        lt_t budget_ns = p_ns/2;
+        lt_t duration = s2ns(10);
+        lt_t terminate_time;
+        unsigned int first_job, last_job;
+        int opt;
+        struct rt_task param;
+        budget_drain_policy_t drain_policy = DRAIN_SIMPLE;
+        int compute_overrun_rate = 0;
+        int once = 1;
+
+
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch(opt) {
+                case 's':
+                        SIGNALS = 1;
+                        break;
+                case 'b':
+                        BLOCK_SIGNALS_ON_SLEEP = 1;
+                        break;
+                case 'o':
+                        OVERRUN = 1;
+                        overrun_extra = budget_ns/2;
+                        break;
+                case 'O':
+                        OVERRUN = 1;
+                        overrun_extra = 4*p_ns;
+                        break;
+                case 'a':
+                        /* select an overrun rate such that a task should be caught
+                         * up from a backlog caused by an overrun before the next
+                         * overrun occurs.
+                         */
+                        compute_overrun_rate = 1;
+                        break;
+                case 'v':
+                        drain_policy = DRAIN_SOBLIV;
+                        break;
+                case ':':
+                        printf("missing argument\n");
+                        assert(false);
+                        break;
+                default:
+                        printf("unknown option\n");
+                        assert(false);
+                        break;
+                }
+        }
+
+        assert(!BLOCK_SIGNALS_ON_SLEEP || (BLOCK_SIGNALS_ON_SLEEP && SIGNALS));
+
+        if (compute_overrun_rate) {
+                int backlog = (int)ceil((overrun_extra + budget_ns)/(double)budget_ns);
+                OVERRUN_RATE = backlog + 2; /* some padding */
+        }
+
+        init_rt_task_param(&param);
+        param.exec_cost = budget_ns;
+        param.period = p_ns;
+        param.release_policy = PERIODIC;
+        param.drain_policy = drain_policy;
+        if (!SIGNALS)
+                param.budget_policy = PRECISE_ENFORCEMENT;
+        else
+                param.budget_signal_policy = PRECISE_SIGNALS;
+
+        init_litmus();
+
+        ret = set_rt_task_param(gettid(), &param);
+        assert(ret == 0);
+
+        ret = task_mode(LITMUS_RT_TASK);
+        assert(ret == 0);
+
+        sleep_next_period();
+
+        ret = get_job_no(&first_job);
+        assert(ret == 0);
+
+        terminate_time = duration + wtime_ns();
+
+        while (wtime_ns() < terminate_time) {
+                try{
+                        if(once) {
+                                activate_litmus_signals(SIG_BUDGET, litmus::throw_on_litmus_signal);
+                                once = 0;
+                        }
+                        job(e_ns, budget_ns);
+                }
+                catch(const litmus::sigbudget &e) {
+                        /* drop silently */
+                }
+        }
+
+        ret = get_job_no(&last_job);
+        assert(ret == 0);
+
+        ret = task_mode(BACKGROUND_TASK);
+        assert(ret == 0);
+
+        printf("# Kernel Jobs: %d\n", last_job - first_job + 1);
+        printf("# User Started Jobs: %d\n", NUM_JOBS);
+        printf("# User Jobs Completed: %d\n", NUM_COMPLETED_JOBS);
+        printf("# Overruns: %d\n", NUM_OVERRUNS);
+
+        return 0;
+}