From 7e062f5db3e3888cda2d0915e14d33b9f69c4c68 Mon Sep 17 00:00:00 2001 From: "Bjoern B. Brandenburg" Date: Wed, 23 Jan 2008 11:26:36 -0500 Subject: Reorganized file layout. --- bin/hrt.c | 78 +++++++++++++++++++++++++++ bin/iotest.c | 74 +++++++++++++++++++++++++ bin/mode_test.c | 116 +++++++++++++++++++++++++++++++++++++++ bin/np_test.c | 56 +++++++++++++++++++ bin/rt_launch.c | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++ bin/run.c | 8 +++ bin/set_rt_mode.c | 46 ++++++++++++++++ bin/show_scheduler.c | 10 ++++ bin/stdump.c | 44 +++++++++++++++ bin/timeout.c | 36 +++++++++++++ bin/wait_test.c | 103 +++++++++++++++++++++++++++++++++++ 11 files changed, 720 insertions(+) create mode 100644 bin/hrt.c create mode 100644 bin/iotest.c create mode 100644 bin/mode_test.c create mode 100644 bin/np_test.c create mode 100644 bin/rt_launch.c create mode 100644 bin/run.c create mode 100644 bin/set_rt_mode.c create mode 100644 bin/show_scheduler.c create mode 100644 bin/stdump.c create mode 100644 bin/timeout.c create mode 100644 bin/wait_test.c (limited to 'bin') diff --git a/bin/hrt.c b/bin/hrt.c new file mode 100644 index 0000000..224293c --- /dev/null +++ b/bin/hrt.c @@ -0,0 +1,78 @@ +#include +#include +#include + +#include "edf-hsb.h" + + +void usage(char *name) +{ + fprintf(stderr, + "EDF-HSB server setup utility\n" + "Usage: %s hrt show <#cpu>\n" + " %s hrt set <#cpu> \n" + " %s be create \n", + name, name, name); + exit(1); +} + + +int hrt(int argc, char** argv) +{ + int wcet, period, cpu; + + if (argc == 2 && !strcmp(argv[0], "show")) { + cpu = atoi(argv[1]); + if (!get_hrt(cpu, &wcet, &period)) + printf("HRT/%d = (%d, %d)\n", cpu, wcet, period); + else + perror("cannot read HRT settings"); + } else if (argc == 4 && !strcmp(argv[0], "set")) { + cpu = atoi(argv[1]); + wcet = atoi(argv[2]); + period = atoi(argv[3]); + printf("Setting HRT/%d to (%d, %d)", cpu, wcet, period); + if (!set_hrt(cpu, wcet, period)) + printf(" OK.\n"); + else { + printf("\n"); + perror("cannot write HRT settings"); + } + } else + return 1; + + return 0; +} + +int be(int argc, char** argv) +{ + int wcet, period; + if (argc == 3 && !strcmp(argv[0], "create")) { + wcet = atoi(argv[1]); + period = atoi(argv[2]); + printf("Creating BE with (%d, %d)", wcet, period); + if (!create_be(wcet, period)) + printf(" OK.\n"); + else { + printf("\n"); + perror("cannot create BE server"); + } + return 0; + } + else + return 1; +} + +int main(int argc, char** argv) +{ + int ret = 1; + if (argc > 1) { + if (!strcmp(argv[1], "hrt")) + ret = hrt(argc - 2, argv + 2); + else if (!strcmp(argv[1], "be")) + ret = be(argc - 2, argv + 2); + } + if (ret) + usage(argv[0]); + return ret; +} diff --git a/bin/iotest.c b/bin/iotest.c new file mode 100644 index 0000000..ac07e74 --- /dev/null +++ b/bin/iotest.c @@ -0,0 +1,74 @@ +#include +#include +#include +#include +#include +#include + +#include "litmus.h" + +#define US_PER_MS 1000 + +int iotest(void *nil) { + int id = getpid(); + FILE* file; + char str[255]; + unsigned long last = 0; + struct timeval time; + + printf("I'am real time task %d doing IO!\n", id); + snprintf(str, sizeof(str), "rt-io-%d.txt", id); + file = fopen(str, "w"); + if (!file) { + perror("could not open file for output"); + exit(1); + } + while (1) { + gettimeofday(&time, NULL); + if (time.tv_usec - last > US_PER_MS) { + fprintf(file, "ran at %lus %lums\n", time.tv_sec, time.tv_usec / US_PER_MS); + last = time.tv_usec; + } + fflush(file); + } + return id; +} + +#define NUMTASKS 4 + +int main(int argc, char** argv) +{ + int rt_task[NUMTASKS]; + int i; + int ret, pid; + + for (i = 0; i < NUMTASKS; i++) { + /* func arg cpu wcet period */ + rt_task[i] = create_rt_task(iotest, NULL, 0, 25, 100); + if (rt_task[i] < 0) { + perror("Could not create rt child process"); + } + } + + sync(); + sync(); + + printf(":: Starting real-time mode.\n"); + set_rt_mode(MODE_RT_RUN); + + printf(":: Sleeping...\n"); + sleep(120); + + printf("Killing real-time tasks.\n"); + for (i = 0; i < NUMTASKS; i++) { + printf(":: sending SIGKILL to %d\n", rt_task[i]); + kill(rt_task[i], SIGKILL); + } + for (i = 0; i < NUMTASKS; i++) { + pid = wait(&ret); + printf(":: %d exited with status %d\n", pid, ret); + } + printf(":: Leaving real-time mode.\n"); + set_rt_mode(MODE_NON_RT); + return 0; +} diff --git a/bin/mode_test.c b/bin/mode_test.c new file mode 100644 index 0000000..8bdf21b --- /dev/null +++ b/bin/mode_test.c @@ -0,0 +1,116 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "litmus.h" + +#define US_PER_MS 1000 + +int prefix(void) +{ + char field[1024]; + int prefix[1024]; + int i, sum = 0; + + for (i = 0; i < 1024; i++) { + sum += field[i]; + prefix[i] = sum; + } + return sum; +} + +void do_stuff(void) +{ + int i =0, j =0; + + for (; i < 50000; i++) + j += prefix(); +} + +#define CALL(sc) do { ret = sc; if (ret == -1) {perror(" (!!) " #sc " failed"); /*exit(1)*/;}} while (0); + +unsigned int job_no; + +void next(void) +{ + int ret; + unsigned int actual; + CALL(get_job_no(&actual)); + CALL(wait_for_job_release(++job_no)); + printf("Now executing job %u, waited for %u\n", actual, job_no); +} + +int main(int argc, char** argv) +{ + int ret; + + init_litmus(); + + CALL(getpid()); + printf("my pid is %d\n", ret); + + + CALL(get_job_no(&job_no)); + printf("my job_no is %u", job_no); + + CALL( task_mode(LITMUS_RT_TASK) ); + + CALL( sporadic_global(3, 33) ); + + CALL( task_mode(LITMUS_RT_TASK) ); + + next(); + do_stuff(); + + next(); + do_stuff(); + + next(); + do_stuff(); + + CALL( task_mode(BACKGROUND_TASK) ); + + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + + CALL( task_mode(LITMUS_RT_TASK) ); + + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + + + next(); + next(); + next(); + next(); + next(); + next(); + next(); + + + next(); + do_stuff(); + + next(); + do_stuff(); + + next(); + do_stuff(); + + CALL( task_mode(BACKGROUND_TASK) ); + printf("Exiting...\n"); + + return 0; +} diff --git a/bin/np_test.c b/bin/np_test.c new file mode 100644 index 0000000..dad68aa --- /dev/null +++ b/bin/np_test.c @@ -0,0 +1,56 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "litmus.h" + +#define US_PER_MS 1000 + +#define NUMTASKS 4 + +int prefix(void) +{ + char field[1024]; + int prefix[1024]; + int i, sum = 0; + + for (i = 0; i < 1024; i++) { + sum += field[i]; + prefix[i] = sum; + } + return sum; +} + + +void do_stuff(void) +{ + int i =0, j =0; + + for (; i < 50000; i++) + j += prefix(); +} + +#define CALL(sc) do { ret = sc; if (ret == -1) {perror(" (!!) " #sc " failed: "); /*exit(1)*/;}} while (0); + + +int main(int argc, char** argv) +{ + int ret; + + init_litmus(); + + enter_np(); + + do_stuff(); + + exit_np(); + + + return 0; +} diff --git a/bin/rt_launch.c b/bin/rt_launch.c new file mode 100644 index 0000000..d888365 --- /dev/null +++ b/bin/rt_launch.c @@ -0,0 +1,149 @@ +#include +#include +#include +#include +#include +#include + +#include "litmus.h" +#include "adaptive.h" + +typedef struct { + char * exec_path; + char ** argv; +} startup_info_t; + + +int launch(void *task_info_p) { + startup_info_t *info = (startup_info_t*) task_info_p; + int ret; + ret = execvp(info->exec_path, info->argv); + perror("execv failed"); + return ret; +} + +void usage(char *error) { + fprintf(stderr, "%s\nUsage: \nlaunch_rt supports one of two modes:\n" + "\n\tlaunch_rt program arg1 arg2 ...\n" + "\n\tlaunch_rt program arg1 arg2 ...\n" + "\nwhere:" + "\n\t = " + "[-c {hrt|srt|be}] [-p ]\n" + "\n\t = " + "(-a weight/period/utility)+\n" + "\nExamples:" + "\n\trt_launch -p 2 10 100 cpu_job" + "\n\t => Launch cpu_job a hard real-time task with " + "\n\t period 100 and weight 0.1 on CPU 2.\n" + "\n\trt_launch -a 0.1/100/0.4 -a 0.2/75/0.5 adaptive_job" + "\n\t => Launch adaptive_job with two service levels" + "\n\n", + error); + exit(1); +} + +/* argument format should be weight/period/utility */ +static int parse_service_level(service_level_t* level, char* str) +{ + char *weight, *period, *utility; + double u, w; + weight = strtok(str, "/"); + period = strtok(NULL, "/"); + utility = strtok(NULL, "/"); + str = strtok(NULL, "/"); + + if (str || !utility || !period || !weight) + return 0; + + w = atof(weight); + u = atof(utility); + level->weight = f2fp(w); + level->period = atol(period); + level->value = f2fp(u); + + if (level->period == 0 || + u <= 0.0 || u > 1.0 || w <= 0.0 || w > 1.0) + return 0; + return 1; +} + + +#define OPTSTR "p:c:a:" + +int main(int argc, char** argv) +{ + int ret; + int wcet; + int period; + int cpu = 0; + int opt; + startup_info_t info; + task_class_t class = RT_CLASS_HARD; + + int adaptive = 0; + unsigned int level = 0; + service_level_t slevel[MAX_SERVICE_LEVELS]; + + while ((opt = getopt(argc, argv, OPTSTR)) != -1) { + switch (opt) { + case 'a': + adaptive = 1; + if (level == MAX_SERVICE_LEVELS) + usage("Too many service levels."); + if (!parse_service_level(slevel + level++, optarg)) + usage("Bad service level."); + break; + case 'p': + cpu = atoi(optarg); + break; + case 'c': + class = str2class(optarg); + if (class == -1) + usage("Unknown task class."); + break; + + case ':': + usage("Argument missing."); + break; + case '?': + default: + usage("Bad argument."); + break; + } + } + + signal(SIGUSR1, SIG_IGN); + + if (!adaptive) { + if (argc - optind < 3) + usage("Arguments missing."); + wcet = atoi(argv[optind + 0]); + period = atoi(argv[optind + 1]); + if (wcet <= 0) + usage("The worst-case execution time must be a " + "positive number."); + if (period <= 0) + usage("The period must be a positive number."); + if (wcet > period) { + usage("The worst-case execution time must not " + "exceed the period."); + } + info.exec_path = argv[optind + 2]; + info.argv = argv + optind + 2; + ret = __create_rt_task(launch, &info, cpu, wcet, period, class); + } else { + if (argc == optind) + usage("Arguments missing."); + info.exec_path = argv[optind]; + info.argv = argv + optind; + ret = create_adaptive_rt_task(launch, &info, level, slevel); + } + + + if (ret < 0) { + perror("Could not create rt child process"); + return 2; + } + + return 0; +} diff --git a/bin/run.c b/bin/run.c new file mode 100644 index 0000000..3719d6f --- /dev/null +++ b/bin/run.c @@ -0,0 +1,8 @@ + + +int main(int argc, char** argv) +{ + int i; + for (i = 0; i < 500000000; i++); + return 0; +} diff --git a/bin/set_rt_mode.c b/bin/set_rt_mode.c new file mode 100644 index 0000000..510da70 --- /dev/null +++ b/bin/set_rt_mode.c @@ -0,0 +1,46 @@ +#include +#include +#include +#include +#include + +#include "litmus.h" + + +void die(const char* str) +{ + fprintf(stderr, "%s\n%s\n", str, + "Usage: set_rt_mode [-v] {on|off}"); + exit(127); +} + +int main(int argc, char** argv) +{ + int ret; + int verbose = 0; + char* cmd = argv[1]; + + if (argc == 3 && !strcmp(argv[1], "-v")) { + verbose = 1; + cmd = argv[2]; + } + if (argc == 2 || verbose) { + if (!strcmp(cmd, "on")) { + if (verbose) + printf("Enabling real-time mode.\n"); + ret = set_rt_mode(MODE_RT_RUN); + if (ret && verbose) + perror("set_rt_mode failed"); + exit(ret ? errno : 0); + } else if (!strcmp(cmd, "off")) { + if (verbose) + printf("Disabling real-time mode.\n"); + ret = set_rt_mode(MODE_NON_RT); + if (ret && verbose) + perror("set_rt_mode failed"); + exit(ret ? errno : 0); + } + } + die("Bad arguments."); + return 0; +} diff --git a/bin/show_scheduler.c b/bin/show_scheduler.c new file mode 100644 index 0000000..7026e2a --- /dev/null +++ b/bin/show_scheduler.c @@ -0,0 +1,10 @@ +#include +#include + +#include "litmus.h" + +int main(int argc, char** argv) { + spolicy scheduler = sched_getpolicy(); + printf("%s\n", get_scheduler_name(scheduler)); + return 0; +} diff --git a/bin/stdump.c b/bin/stdump.c new file mode 100644 index 0000000..282fb31 --- /dev/null +++ b/bin/stdump.c @@ -0,0 +1,44 @@ +#include +#include +#include + + +#include "litmus.h" +#include "adaptive.h" +#include "sched_trace.h" + +int show_sl_chg(trace_header_t* hdr) +{ + service_level_change_record_t *rec; + + rec = (service_level_change_record_t*) hdr; + printf("SL CHANGE : PID=%d PERIOD=%lu\n", rec->task.pid, + rec->new_level.period); + return 0; +} + +int show_weight_error(trace_header_t* hdr) +{ + weight_error_record_t *rec; + + rec = (weight_error_record_t*) hdr; + printf("WEIGHT ERR: PID=%d EST=%5.4f ACT=%5.4f\n", rec->task, + fp2f(rec->estimate), fp2f(rec->actual)); + return 0; +} + + +int main(int argc, char** argv) +{ + record_callback_t cb; + int ret; + + init_record_callback(&cb); + set_callback(ST_SERVICE_LEVEL_CHANGE, show_sl_chg, &cb); + set_callback(ST_WEIGHT_ERROR, show_weight_error, &cb); + + ret = walk_sched_trace_files_ordered(argv + 1, argc - 1, 0, &cb); + if (ret != 0) + perror("walk failed"); + return 0; +} diff --git a/bin/timeout.c b/bin/timeout.c new file mode 100644 index 0000000..ba513f9 --- /dev/null +++ b/bin/timeout.c @@ -0,0 +1,36 @@ +#include +#include +#include + +#include "litmus.h" + +int main(int argc, char** argv) +{ + int timeout; + rt_param_t my_param; + + if (argc != 2) + { + printf("Usage: %s \n", argv[0]); + exit(1); + } + timeout = atoi(argv[1]); + if (timeout <= 0) { + printf("Timeout must be a positive number.\n"); + exit(1); + } + + /* printf("This is the kill real-time mode task.\n" + "Expected end of real %u seconds.\n", timeout); + */ + /* get_rt_task_param(getpid(), &my_param); + show_rt_param(&my_param); + */ + + sleep(timeout); + + + set_rt_mode(MODE_NON_RT); + printf("End of real-time mode.\n"); + return 0; +} diff --git a/bin/wait_test.c b/bin/wait_test.c new file mode 100644 index 0000000..efd4d90 --- /dev/null +++ b/bin/wait_test.c @@ -0,0 +1,103 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "litmus.h" + +#define US_PER_MS 1000 + +#define NUMTASKS 4 + +int prefix(void) +{ + char field[1024]; + int prefix[1024]; + int i, sum = 0; + + for (i = 0; i < 1024; i++) { + sum += field[i]; + prefix[i] = sum; + } + return sum; +} + + +void do_stuff(void) +{ + int i =0, j =0; + + for (; i < 50000; i++) + j += prefix(); +} + +#define CALL(sc) do { ret = sc; if (ret == -1) {perror(" (!!) " #sc " failed: "); /*exit(1)*/;}} while (0); + +unsigned int job_no; + + +void next(void) +{ + int ret; + unsigned int actual; + CALL(get_job_no(&actual)); + CALL(wait_for_job_release(++job_no)); + printf("Now executing job %u, waited for %u\n", actual, job_no); +} + +void sync_jobs(void) +{ + int ret; + unsigned int actual; + CALL(get_job_no(&actual)); + job_no = actual; +} + + +int main(int argc, char** argv) +{ + int ret; + + init_litmus(); + + CALL(getpid()); + printf("my pid is %d\n", ret); + + + CALL(get_job_no(&job_no)); + printf("my job_no is %u", job_no); + + next(); + next(); + next(); + + /* now overrun a job for good */ + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + do_stuff(); + + + next(); + next(); + next(); + next(); + sync_jobs(); + next(); + next(); + next(); + + + return 0; +} -- cgit v1.2.2