Test tool budget enforcement methods.

1 files changed, 235 insertions, 0 deletions

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;
+}