Change liblitmus to have a more sane repository layout.

11 files changed, 813 insertions, 0 deletions

diff --git a/src/edf-hsb.c b/src/edf-hsb.c
new file mode 100644
index 0000000..9ace2ca
--- /dev/null
+++ b/src/edf-hsb.c
@@ -0,0 +1,48 @@
+#include "litmus.h"
+#include "edf-hsb.h"
+
+
+typedef enum {
+        EDF_HSB_SET_HRT,
+        EDF_HSB_GET_HRT,
+        EDF_HSB_CREATE_BE
+} edf_hsb_setup_cmds_t;
+
+typedef struct {
+        int             cpu;
+        unsigned int    wcet;
+        unsigned int    period;
+} setup_hrt_param_t;
+
+typedef struct {
+        unsigned int    wcet;
+        unsigned int    period;
+} create_be_param_t;
+
+int set_hrt(int cpu, unsigned int  wcet, unsigned int  period)
+{
+        setup_hrt_param_t param;
+        param.cpu    = cpu;
+        param.wcet   = wcet;
+        param.period = period;
+        return scheduler_setup(EDF_HSB_SET_HRT, &param);
+}
+
+int get_hrt(int cpu, unsigned int *wcet, unsigned int *period)
+{
+        setup_hrt_param_t param;
+        int ret;
+        param.cpu    = cpu;
+        ret = scheduler_setup(EDF_HSB_GET_HRT, &param);
+        *wcet   = param.wcet;
+        *period = param.period;
+        return ret;
+}
+
+int create_be(unsigned int wcet, unsigned int period) 
+{
+        create_be_param_t param;
+        param.wcet   = wcet;
+        param.period = period;
+        return scheduler_setup(EDF_HSB_CREATE_BE, &param);
+}
diff --git a/src/hrt.c b/src/hrt.c
new file mode 100644
index 0000000..224293c
--- /dev/null
+++ b/src/hrt.c
@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#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> <wcet> <period>\n"
+                "       %s be  create         <wcet> <period>\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/src/iotest.c b/src/iotest.c
new file mode 100644
index 0000000..ac07e74
--- /dev/null
+++ b/src/iotest.c
@@ -0,0 +1,74 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+
+#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/src/litmus.c b/src/litmus.c
new file mode 100644
index 0000000..65ad294
--- /dev/null
+++ b/src/litmus.c
@@ -0,0 +1,295 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/mman.h>
+
+
+#include "litmus.h"
+
+
+/* this is missing in newer linux/unistd.h versions */
+
+#define _syscall0(type,name) \
+type name(void) \
+{\
+        return syscall(__NR_##name);\
+}
+
+#define _syscall1(type,name,type1,arg1) \
+type name(type1 arg1) \
+{\
+        return syscall(__NR_##name, arg1);\
+}
+
+
+#define _syscall2(type,name,type1,arg1,type2,arg2) \
+type name(type1 arg1,type2 arg2) \
+{\
+        return syscall(__NR_##name, arg1, arg2);\
+}
+
+
+/* clear the TID in the child */
+#define CLONE_CHILD_CLEARTID    0x00200000      
+/* set the TID in the child */
+#define CLONE_CHILD_SETTID      0x01000000
+/* don't let the child run before we have completed setup */
+#define CLONE_STOPPED           0x02000000      
+/* litmus clone flag */
+#define CLONE_REALTIME          0x10000000
+
+/* CLONE_REALTIME is necessary because CLONE_STOPPED will put a SIGSTOP in 
+ * the pending signal queue. Thus the first thing a newly created task will
+ * do after it is released is to stop, which is not what we want
+ * 
+ * CLONE_REALTIME just sets the status to TASK_STOPPED without queueing a 
+ * signal.
+ */
+
+
+/* this is essentially a fork with CLONE_STOPPED */
+/* #define CLONE_LITMUS  CLONE_STOPPED | CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID */
+#define CLONE_LITMUS CLONE_REALTIME | CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID
+
+/* we need to override libc because it wants to be clever 
+ * and rejects our call without presenting it even to the kernel
+ */
+#define __NR_raw_clone          120
+
+
+_syscall2(int, raw_clone, unsigned long, flags, unsigned long, child_stack)
+
+
+const char* get_scheduler_name(spolicy scheduler) 
+{
+        const char* name;
+
+        switch (scheduler){
+        case SCHED_LINUX :
+                name = "Linux";
+                break;
+        case SCHED_PFAIR:
+                name = "Pfair";
+                break;
+        case SCHED_PFAIR_STAGGER:
+                name = "Pfair (staggered)";
+                break;
+        case SCHED_PART_EDF:
+                name = "Partioned EDF";
+                break;
+        case SCHED_PART_EEVDF:
+                name = "Partioned EEVDF";
+                break;
+        case SCHED_GLOBAL_EDF:
+                name = "Global EDF";
+                break;
+        case SCHED_EDF_HSB:
+                name = "EDF-HSB";
+                break;
+        case SCHED_GSN_EDF:
+                name = "GSN-EDF";
+                break;
+        case SCHED_PSN_EDF:
+                name = "PSN-EDF";
+                break;
+        default:
+                name = "Unkown";
+                break;
+        }
+        return name;
+}
+
+int create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period) {
+        return __create_rt_task(rt_prog, arg, cpu, wcet, period, RT_CLASS_HARD);
+}
+
+int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period,
+                     task_class_t class) 
+{
+        int ret;
+        rt_param_t params;
+        int rt_task = raw_clone(CLONE_LITMUS, 0);
+
+        if (rt_task < 0) 
+                return rt_task;
+
+        if (rt_task > 0) {
+                /* we are the controller task */                        
+                params.period      = period;
+                params.exec_cost   = wcet;
+                params.cpu         = cpu;
+                params.cls         = class;
+                ret = set_rt_task_param(rt_task, &params);
+                if (ret < 0) {
+                        /* we have a problem: we created the task but
+                         * for some stupid reason we cannot set the real-time
+                         * parameters. We must clean up the stopped task.
+                         */
+                        kill(rt_task, SIGKILL);
+                        /* syscall will have set errno, we don't have to do
+                         * anything
+                         */
+                        return -1;
+                }
+                ret = prepare_rt_task(rt_task);
+                if (ret < 0) {
+                        /* same problem as above*/
+                        //kill(rt_task, SIGKILL);
+                        rt_task = -1;
+                }
+                return rt_task;
+        }
+        else {
+                /* we are the real-time task 
+                 * launch task and die when it is done
+                 */             
+                
+                exit(rt_prog(arg));
+        }
+}
+
+
+void show_rt_param(rt_param_t* tp) 
+{
+        printf("rt params:\n\t"
+               "exec_cost:\t%ld\n\tperiod:\t\t%ld\n\tcpu:\t%d\n",
+               tp->exec_cost, tp->period, tp->cpu);
+}
+
+task_class_t str2class(const char* str) 
+{
+        if      (!strcmp(str, "hrt"))
+                return RT_CLASS_HARD;
+        else if (!strcmp(str, "srt"))
+                return RT_CLASS_SOFT;
+        else if (!strcmp(str, "be"))
+                return RT_CLASS_BEST_EFFORT;
+        else
+                return -1;
+}
+
+
+
+struct np_flag {
+        #define RT_PREEMPTIVE           0x2050 /* = NP */
+        #define RT_NON_PREEMPTIVE       0x4e50 /* =  P */
+        unsigned short preemptivity;
+
+        #define RT_EXIT_NP_REQUESTED    0x5251 /* = RQ */
+        unsigned short request;
+
+        unsigned int ctr;
+};
+
+static struct np_flag np_flag;
+
+int register_np_flag(struct np_flag* flag);
+int signal_exit_np(void);
+
+
+static inline void barrier(void)
+{
+        __asm__ __volatile__("sfence": : :"memory");
+}
+
+void enter_np(void)
+{
+        if (++np_flag.ctr == 1)
+        {
+                np_flag.request = 0;
+                barrier();
+                np_flag.preemptivity = RT_NON_PREEMPTIVE;
+        }
+}
+
+
+void exit_np(void)
+{
+        if (--np_flag.ctr == 0)
+        {
+                np_flag.preemptivity = RT_PREEMPTIVE;
+                barrier();
+                if (np_flag.request == RT_EXIT_NP_REQUESTED)
+                        signal_exit_np();
+        }
+}
+
+
+#define check(str) if (ret == -1) {perror(str); fprintf(stderr, \
+        "Could not initialize LITMUS^RT, aborting...\n"); exit(1);}
+
+void init_litmus(void)
+{
+        int ret;
+        np_flag.preemptivity = RT_PREEMPTIVE;
+        np_flag.ctr = 0;
+
+        ret = mlockall(MCL_CURRENT | MCL_FUTURE);
+        check("mlockall");
+        ret = register_np_flag(&np_flag);
+        check("register_np_flag");      
+}
+
+
+
+/*      Litmus syscalls definitions */
+#define __NR_sched_setpolicy      320
+#define __NR_sched_getpolicy      321
+#define __NR_set_rt_mode          322
+#define __NR_set_rt_task_param    323
+#define __NR_get_rt_task_param    324
+#define __NR_prepare_rt_task      325
+#define __NR_reset_stat           326
+#define __NR_sleep_next_period    327
+#define __NR_scheduler_setup      328
+#define __NR_register_np_flag     329
+#define __NR_signal_exit_np       330
+#define __NR_pi_sema_init         331
+#define __NR_pi_down              332
+#define __NR_pi_up                333
+#define __NR_pi_sema_free         334
+#define __NR_sema_init            335
+#define __NR_down                 336
+#define __NR_up                   337
+#define __NR_sema_free            338
+#define __NR_srp_sema_init        339
+#define __NR_srp_down             340
+#define __NR_srp_up               341
+#define __NR_reg_task_srp_sem     342
+#define __NR_srp_sema_free        343
+#define __NR_get_job_no           344
+#define __NR_wait_for_job_release 345
+
+
+/*      Syscall stub for setting RT mode and scheduling options */
+_syscall1(spolicy, sched_setpolicy,   spolicy, arg1);
+_syscall0(spolicy, sched_getpolicy);
+_syscall1(int,     set_rt_mode,       int,         arg1);
+_syscall2(int,     set_rt_task_param, pid_t,       pid,    rt_param_t*, arg1);
+_syscall2(int,     get_rt_task_param, pid_t,       pid,    rt_param_t*, arg1);
+_syscall1(int,     prepare_rt_task,   pid_t,       pid);
+_syscall0(int,     reset_stat);
+_syscall0(int,     sleep_next_period);
+_syscall2(int,     scheduler_setup,   int,         cmd,    void*,       param);
+_syscall1(int,     register_np_flag, struct np_flag*, flag);
+_syscall0(int,     signal_exit_np);
+_syscall0(int,     pi_sema_init);
+_syscall1(int,     pi_down,           pi_sema_id,  sem_id);
+_syscall1(int,     pi_up,             pi_sema_id,  sem_id);
+_syscall1(int,     pi_sema_free,      pi_sema_id,  sem_id);
+_syscall0(int,     sema_init);
+_syscall1(int,     down,              sema_id,     sem_id);
+_syscall1(int,     up,                sema_id,     sem_id);
+_syscall1(int,     sema_free,         sema_id,     sem_id);
+_syscall0(int,     srp_sema_init);
+_syscall1(int,     srp_down,          srp_sema_id, sem_id);
+_syscall1(int,     srp_up,            srp_sema_id, sem_id);
+_syscall2(int,     reg_task_srp_sem,  srp_sema_id, sem_id, pid_t,       t_pid);
+_syscall1(int,     srp_sema_free,     srp_sema_id, sem_id);
+_syscall1(int,     get_job_no,      unsigned int*, job_no);
+_syscall1(int,     wait_for_job_release, unsigned int, job_no);
+
diff --git a/src/np_test.c b/src/np_test.c
new file mode 100644
index 0000000..dad68aa
--- /dev/null
+++ b/src/np_test.c
@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#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/src/rt_launch.c b/src/rt_launch.c
new file mode 100644
index 0000000..31e6447
--- /dev/null
+++ b/src/rt_launch.c
@@ -0,0 +1,83 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "litmus.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 = execv(info->exec_path, info->argv);
+        perror("execv failed");
+        return ret;
+}
+
+void usage(char *error) {
+        fprintf(stderr, "%s\nUsage: launch_rt [-c {hrt|srt|be}] [-p <cpu>]"
+                "<wcet> <period> program arg1 arg2 ...\n",
+                error);
+        exit(1);
+}
+
+#define OPTSTR "p:c:"
+
+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;
+        
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch (opt) {
+                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("Unknown flag.");
+                        break;
+                }
+        }
+
+        if (argc - optind < 3)
+        {
+                printf("argc: %d optind: %d\n", argc, optind);
+                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);
+        if (ret < 0) {
+                perror("Could not create rt child process");
+        }
+
+        return 0;       
+}
diff --git a/src/run.c b/src/run.c
new file mode 100644
index 0000000..3719d6f
--- /dev/null
+++ b/src/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/src/set_rt_mode.c b/src/set_rt_mode.c
new file mode 100644
index 0000000..5936d7d
--- /dev/null
+++ b/src/set_rt_mode.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <strings.h>
+#include <stdlib.h>
+#include "litmus.h"
+
+
+int main(int argc, char** argv) 
+{
+        if (argc == 2) {
+                if (!strcmp(argv[1], "on")) {
+                        printf("Enabling real-time mode.\n");
+                        set_rt_mode(MODE_RT_RUN);                       
+                        exit(0);
+                } else if (!strcmp(argv[1], "off")) {
+                        printf("Disabling real-time mode.\n");
+                        set_rt_mode(MODE_NON_RT);                       
+                        exit(0);
+                } 
+        }
+        printf("Usage: %s {on|off}\n", argv[0]);
+        return 1;       
+}
diff --git a/src/show_scheduler.c b/src/show_scheduler.c
new file mode 100644
index 0000000..7026e2a
--- /dev/null
+++ b/src/show_scheduler.c
@@ -0,0 +1,10 @@
+#include <sys/types.h>
+#include <stdio.h>
+
+#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/src/timeout.c b/src/timeout.c
new file mode 100644
index 0000000..ba513f9
--- /dev/null
+++ b/src/timeout.c
@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "litmus.h"
+
+int main(int argc, char** argv) 
+{
+        int timeout;
+        rt_param_t my_param;
+
+        if (argc != 2) 
+        {
+                printf("Usage: %s <timeout in seconds>\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/src/wait_test.c b/src/wait_test.c
new file mode 100644
index 0000000..efd4d90
--- /dev/null
+++ b/src/wait_test.c
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#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;       
+}