proc_test: code cleanup and introduce a synchronization barrier also for non-preempti...

[bertos.git] / bertos / kern / proc_test.c

diff --git a/bertos/kern/proc_test.c b/bertos/kern/proc_test.c
index 5b5bf3ff663f842ac20c121c7a3b5e871c69c581..cb8b4a0d0bcb023cade65a26436a40012f2f60b0 100644 (file)
--- a/bertos/kern/proc_test.c
+++ b/bertos/kern/proc_test.c
@@ -84,13 +84,17 @@ static char name[TASKS][32];
 
 static unsigned int done[TASKS];
 
-#define WORKER_STACK_SIZE KERN_MINSTACKSIZE * 3
+static cpu_atomic_t barrier[TASKS];
+static cpu_atomic_t main_barrier;
+
+#define WORKER_STACK_SIZE KERN_MINSTACKSIZE * 2
 
 /* Base time delay for processes using timer_delay() */
 #define DELAY  5
 
 // Define process stacks for test.
-static cpu_stack_t worker_stack[TASKS][WORKER_STACK_SIZE / sizeof(cpu_stack_t)];
+static cpu_stack_t worker_stack[TASKS][(WORKER_STACK_SIZE +
+                       sizeof(cpu_stack_t) - 1) / sizeof(cpu_stack_t)];
 
 static int prime_numbers[] =
 {
@@ -100,35 +104,75 @@ static int prime_numbers[] =
 
 STATIC_ASSERT(TASKS <= countof(prime_numbers));
 
+#if CONFIG_KERN_PREEMPT
+/* Time to run each preemptible thread (in seconds) */
+#define TIME   10
+
+static unsigned int preempt_counter[TASKS];
+static unsigned int preempt_done[TASKS];
+#endif
+
+static void cleanup(void)
+{
+#if CONFIG_KERN_PREEMPT
+       // Clear shared data (this is needed when this testcase is embedded in
+       // the demo application).
+       memset(preempt_counter, 0, sizeof(preempt_counter));
+       memset(preempt_done, 0, sizeof(preempt_done));
+#endif /* CONFIG_KERN_PREEMPT */
+       memset(done, 0, sizeof(done));
+       memset(barrier, 0, sizeof(barrier));
+       main_barrier = 0;
+}
+
 static void worker(void)
 {
-       long pid = (long)proc_currentUserData();
+       ssize_t pid = (ssize_t)proc_currentUserData();
        long tot = prime_numbers[pid - 1];
        unsigned int my_count = 0;
        int i;
 
+       barrier[pid - 1] = 1;
+       /* Synchronize on the main barrier */
+       while (!main_barrier)
+               proc_yield();
        for (i = 0; i < tot; i++)
        {
                my_count++;
-               PROC_ATOMIC(kprintf("> %s[%ld] running\n", __func__, pid));
+               PROC_ATOMIC(kprintf("> %s[%zd] running\n", __func__, pid));
                timer_delay(tot * DELAY);
        }
        done[pid - 1] = 1;
-       PROC_ATOMIC(kprintf("> %s[%ld] completed\n", __func__, pid));
+       PROC_ATOMIC(kprintf("> %s[%zd] completed\n", __func__, pid));
 }
 
 static int worker_test(void)
 {
-       long i;
+       ssize_t i;
 
        // Init the test processes
+       cleanup();
        kputs("Run Proc test..\n");
        for (i = 0; i < TASKS; i++)
        {
-               sprintf(&name[i][0], "worker_%ld", i + 1);
+               name[i][0] = '\0';
+               snprintf(&name[i][0], sizeof(name[i]), "worker_%zd", i + 1);
+               name[i][sizeof(name[i]) - 1] = '\0';
                proc_new_with_name(name[i], worker, (iptr_t)(i + 1),
                                WORKER_STACK_SIZE, &worker_stack[i][0]);
        }
+       /* Synchronize on start */
+       while (1)
+       {
+               for (i = 0; i < TASKS; i++)
+                       if (!barrier[i])
+                               break;
+               if (i == TASKS)
+                       break;
+               proc_yield();
+       }
+       main_barrier = 1;
+       MEMORY_BARRIER;
        kputs("> Main: Processes started\n");
        while (1)
        {
@@ -147,22 +191,9 @@ static int worker_test(void)
 }
 
 #if CONFIG_KERN_PREEMPT
-/* Time to run each preemptible thread (in seconds) */
-#define TIME   10
-
-static char preempt_name[TASKS][32];
-
-static cpu_atomic_t barrier[TASKS];
-static cpu_atomic_t main_barrier;
-
-static unsigned int preempt_counter[TASKS];
-static unsigned int preempt_done[TASKS];
-
-static cpu_stack_t preempt_worker_stack[TASKS][WORKER_STACK_SIZE / sizeof(cpu_stack_t)];
-
 static void preempt_worker(void)
 {
-       long pid = (long)proc_currentUserData();
+       ssize_t pid = (ssize_t)proc_currentUserData();
        unsigned int *my_count = &preempt_counter[pid - 1];
        ticks_t start, stop;
        int i;
@@ -171,7 +202,7 @@ static void preempt_worker(void)
        /* Synchronize on the main barrier */
        while (!main_barrier)
                proc_yield();
-       PROC_ATOMIC(kprintf("> %s[%ld] running\n", __func__, pid));
+       PROC_ATOMIC(kprintf("> %s[%zd] running\n", __func__, pid));
        start = timer_clock();
        stop  = ms_to_ticks(TIME * 1000);
        while (timer_clock() - start < stop)
@@ -182,7 +213,7 @@ static void preempt_worker(void)
                if (UNLIKELY(*my_count == (unsigned int)~0))
                        *my_count = 1;
        }
-       PROC_ATOMIC(kprintf("> %s[%ld] completed: (counter = %d)\n",
+       PROC_ATOMIC(kprintf("> %s[%zd] completed: (counter = %d)\n",
                                __func__, pid, *my_count));
        for (i = 0; i < TASKS; i++)
                if (!preempt_counter[i])
@@ -196,15 +227,19 @@ static void preempt_worker(void)
 static int preempt_worker_test(void)
 {
        unsigned long score = 0;
-       long i;
+       ssize_t i;
 
        // Init the test processes
+       cleanup();
        kputs("Run Preemption test..\n");
        for (i = 0; i < TASKS; i++)
        {
-               sprintf(&preempt_name[i][0], "preempt_worker_%ld", i + 1);
-               proc_new_with_name(preempt_name[i], preempt_worker, (iptr_t)(i + 1),
-                               WORKER_STACK_SIZE, &preempt_worker_stack[i][0]);
+               name[i][0] = '\0';
+               snprintf(&name[i][0], sizeof(name[i]),
+                               "preempt_worker_%zd", i + 1);
+               name[i][sizeof(name[i]) - 1] = '\0';
+               proc_new_with_name(name[i], preempt_worker, (iptr_t)(i + 1),
+                               WORKER_STACK_SIZE, &worker_stack[i][0]);
        }
        kputs("> Main: Processes created\n");
        /* Synchronize on start */
@@ -334,16 +369,6 @@ out:
  */
 int proc_testRun(void)
 {
-#if CONFIG_KERN_PREEMPT
-       // Clear shared data (this is needed when this testcase is embedded in
-       // the demo application).
-       memset(preempt_counter, 0, sizeof(preempt_counter));
-       memset(preempt_done, 0, sizeof(preempt_done));
-       memset(barrier, 0, sizeof(barrier));
-       main_barrier = 0;
-#endif /* CONFIG_KERN_PREEMPT */
-       memset(done, 0, sizeof(done));
-
        /* Start tests */
        worker_test();
 #if CONFIG_KERN_PREEMPT