bertos/kern/proc_test.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2009 Develer S.r.l. (http://www.develer.com/)
  30  * -->
  31  *
  32  *
  33  * \brief Test kernel preemption.
  34  *
  35  * This testcase spawns TASKS parallel threads that runs for TIME seconds. They
  36  * continuously spin updating a global counter (one counter for each thread).
  37  *
  38  * At exit each thread checks if the others have been che chance to update
  39  * their own counter. If not, it means the preemption didn't occur and the
  40  * testcase returns an error message.
  41  *
  42  * Otherwise, if all the threads have been able to update their own counter it
  43  * means preemption successfully occurs, since there is no active sleep inside
  44  * each thread's implementation.
  45  *
  46  * \author Andrea Righi <arighi@develer.com>
  47  *
  48  * $test$: cp bertos/cfg/cfg_proc.h $cfgdir/
  49  * $test$: echo  "#undef CONFIG_KERN" >> $cfgdir/cfg_proc.h
  50  * $test$: echo "#define CONFIG_KERN 1" >> $cfgdir/cfg_proc.h
  51  * $test$: echo  "#undef CONFIG_KERN_PRI" >> $cfgdir/cfg_proc.h
  52  * $test$: echo "#define CONFIG_KERN_PRI 1" >> $cfgdir/cfg_proc.h
  53  * $test$: echo  "#undef CONFIG_KERN_PREEMPT" >> $cfgdir/cfg_proc.h
  54  * $test$: echo "#define CONFIG_KERN_PREEMPT 1" >> $cfgdir/cfg_proc.h
  55  * $test$: cp bertos/cfg/cfg_monitor.h $cfgdir/
  56  * $test$: sed -i "s/CONFIG_KERN_MONITOR 0/CONFIG_KERN_MONITOR 1/" $cfgdir/cfg_monitor.h
  57  * $test$: cp bertos/cfg/cfg_signal.h $cfgdir/
  58  * $test$: echo  "#undef CONFIG_KERN_SIGNALS" >> $cfgdir/cfg_signal.h
  59  * $test$: echo "#define CONFIG_KERN_SIGNALS 1" >> $cfgdir/cfg_signal.h
  60  *
  61  */
  62
  63 #include <stdio.h> // sprintf
  64 #include <string.h> // memset
  65
  66 #include <kern/proc.h>
  67 #include <kern/irq.h>
  68 #include <kern/monitor.h>
  69
  70 #include <drv/timer.h>
  71 #include <cfg/test.h>
  72 #include <cfg/cfg_proc.h>
  73
  74 enum
  75 {
  76         TEST_OK = 1,
  77         TEST_FAIL = 2,
  78 };
  79
  80 /* Number of tasks to spawn */
  81 #define TASKS   8
  82
  83 static char name[TASKS][32];
  84
  85 static unsigned int done[TASKS];
  86
  87 #define WORKER_STACK_SIZE KERN_MINSTACKSIZE * 3
  88
  89 /* Base time delay for processes using timer_delay() */
  90 #define DELAY   5
  91
  92 // Define process stacks for test.
  93 static cpu_stack_t worker_stack[TASKS][WORKER_STACK_SIZE / sizeof(cpu_stack_t)];
  94
  95 static int prime_numbers[] =
  96 {
  97         1, 3, 5, 7, 11, 13, 17, 19,
  98         23, 29, 31, 37, 41, 43, 47, 53,
  99 };
 100
 101 STATIC_ASSERT(TASKS <= countof(prime_numbers));
 102
 103 static void worker(void)
 104 {
 105         ssize_t pid = (ssize_t)proc_currentUserData();
 106         long tot = prime_numbers[pid - 1];
 107         unsigned int my_count = 0;
 108         int i;
 109
 110         for (i = 0; i < tot; i++)
 111         {
 112                 my_count++;
 113                 PROC_ATOMIC(kprintf("> %s[%zd] running\n", __func__, pid));
 114                 timer_delay(tot * DELAY);
 115         }
 116         done[pid - 1] = 1;
 117         PROC_ATOMIC(kprintf("> %s[%zd] completed\n", __func__, pid));
 118 }
 119
 120 static int worker_test(void)
 121 {
 122         ssize_t i;
 123
 124         // Init the test processes
 125         kputs("Run Proc test..\n");
 126         for (i = 0; i < TASKS; i++)
 127         {
 128                 snprintf(&name[i][0], sizeof(name[i]), "worker_%zd", i + 1);
 129                 name[i][sizeof(name) - 1] = '\0';
 130                 proc_new_with_name(name[i], worker, (iptr_t)(i + 1),
 131                                 WORKER_STACK_SIZE, &worker_stack[i][0]);
 132         }
 133         kputs("> Main: Processes started\n");
 134         while (1)
 135         {
 136                 for (i = 0; i < TASKS; i++)
 137                 {
 138                         if (!done[i])
 139                                 break;
 140                 }
 141                 if (i == TASKS)
 142                         break;
 143                 monitor_report();
 144                 timer_delay(93);
 145         }
 146         kputs("> Main: process test finished..ok!\n");
 147         return 0;
 148 }
 149
 150 #if CONFIG_KERN_PREEMPT
 151 /* Time to run each preemptible thread (in seconds) */
 152 #define TIME    10
 153
 154 static char preempt_name[TASKS][32];
 155
 156 static cpu_atomic_t barrier[TASKS];
 157 static cpu_atomic_t main_barrier;
 158
 159 static unsigned int preempt_counter[TASKS];
 160 static unsigned int preempt_done[TASKS];
 161
 162 static cpu_stack_t preempt_worker_stack[TASKS][WORKER_STACK_SIZE / sizeof(cpu_stack_t)];
 163
 164 static void preempt_worker(void)
 165 {
 166         ssize_t pid = (ssize_t)proc_currentUserData();
 167         unsigned int *my_count = &preempt_counter[pid - 1];
 168         ticks_t start, stop;
 169         int i;
 170
 171         barrier[pid - 1] = 1;
 172         /* Synchronize on the main barrier */
 173         while (!main_barrier)
 174                 proc_yield();
 175         PROC_ATOMIC(kprintf("> %s[%zd] running\n", __func__, pid));
 176         start = timer_clock();
 177         stop  = ms_to_ticks(TIME * 1000);
 178         while (timer_clock() - start < stop)
 179         {
 180                 IRQ_ASSERT_ENABLED();
 181                 (*my_count)++;
 182                 /* be sure to wrap to a value different than 0 */
 183                 if (UNLIKELY(*my_count == (unsigned int)~0))
 184                         *my_count = 1;
 185         }
 186         PROC_ATOMIC(kprintf("> %s[%zd] completed: (counter = %d)\n",
 187                                 __func__, pid, *my_count));
 188         for (i = 0; i < TASKS; i++)
 189                 if (!preempt_counter[i])
 190                 {
 191                         preempt_done[pid - 1] = TEST_FAIL;
 192                         return;
 193                 }
 194         preempt_done[pid - 1] = TEST_OK;
 195 }
 196
 197 static int preempt_worker_test(void)
 198 {
 199         unsigned long score = 0;
 200         ssize_t i;
 201
 202         // Init the test processes
 203         kputs("Run Preemption test..\n");
 204         for (i = 0; i < TASKS; i++)
 205         {
 206                 snprintf(&preempt_name[i][0], sizeof(preempt_name[i]),
 207                                 "preempt_worker_%zd", i + 1);
 208                 preempt_name[i][sizeof(preempt_name) - 1] = '\0';
 209                 proc_new_with_name(preempt_name[i], preempt_worker, (iptr_t)(i + 1),
 210                                 WORKER_STACK_SIZE, &preempt_worker_stack[i][0]);
 211         }
 212         kputs("> Main: Processes created\n");
 213         /* Synchronize on start */
 214         while (1)
 215         {
 216                 for (i = 0; i < TASKS; i++)
 217                         if (!barrier[i])
 218                                 break;
 219                 if (i == TASKS)
 220                         break;
 221                 proc_yield();
 222         }
 223         /* Now all threads have been created, start them all */
 224         main_barrier = 1;
 225         MEMORY_BARRIER;
 226         kputs("> Main: Processes started\n");
 227         while (1)
 228         {
 229                 for (i = 0; i < TASKS; i++)
 230                 {
 231                         if (!preempt_done[i])
 232                                 break;
 233                         else if (preempt_done[i] == TEST_FAIL)
 234                         {
 235                                 kputs("> Main: process test finished..fail!\n");
 236                                 return -1;
 237                         }
 238                 }
 239                 if (i == TASKS)
 240                         break;
 241                 monitor_report();
 242                 timer_delay(1000);
 243         }
 244         for (i = 0; i < TASKS; i++)
 245                 score += preempt_counter[i];
 246         kputs("> Main: process test finished..ok!\n");
 247         kprintf("> Score: %lu\n", score);
 248         return 0;
 249 }
 250 #endif /* CONFIG_KERN_PREEMPT */
 251
 252 #if CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI
 253
 254 #define PROC_PRI_TEST_STACK(num)  PROC_DEFINE_STACK(proc_test##num##_stack, KERN_MINSTACKSIZE);
 255
 256 // Define params to test priority
 257 #define PROC_PRI_TEST(num) static void proc_pri_test##num(void) \
 258 { \
 259         struct Process *main_proc = (struct Process *) proc_currentUserData(); \
 260         kputs("> Process: " #num "\n"); \
 261         sig_signal(main_proc, SIG_USER##num); \
 262 }
 263
 264 // Default priority is 0
 265 #define PROC_PRI_TEST_INIT(num, proc)                                   \
 266 do {                                                                    \
 267         struct Process *p = proc_new(proc_pri_test##num, (proc),        \
 268                                         sizeof(proc_test##num##_stack), \
 269                                         proc_test##num##_stack);        \
 270         proc_setPri(p, num + 1);                                        \
 271 } while (0)
 272
 273 PROC_PRI_TEST_STACK(0)
 274 PROC_PRI_TEST_STACK(1)
 275 PROC_PRI_TEST_STACK(2)
 276
 277 PROC_PRI_TEST(0)
 278 PROC_PRI_TEST(1)
 279 PROC_PRI_TEST(2)
 280
 281 static int prio_worker_test(void)
 282 {
 283         struct Process *curr = proc_current();
 284         int orig_pri = curr->link.pri;
 285         int ret = 0;
 286
 287         // test process priority
 288         // main process must have the higher priority to check signals received
 289         proc_setPri(proc_current(), 10);
 290
 291         kputs("Run Priority test..\n");
 292         // the order in which the processes are created is important!
 293         PROC_PRI_TEST_INIT(0, curr);
 294         PROC_PRI_TEST_INIT(1, curr);
 295         PROC_PRI_TEST_INIT(2, curr);
 296
 297         // signals must be: USER2, 1, 0 in order
 298         sigmask_t signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2);
 299         if (!(signals & SIG_USER2))
 300         {
 301                 ret = -1;
 302                 goto out;
 303         }
 304         signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2);
 305         if (!(signals & SIG_USER1))
 306         {
 307                 ret = -1;
 308                 goto out;
 309         }
 310         signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2);
 311         if (!(signals & SIG_USER0))
 312         {
 313                 ret = -1;
 314                 goto out;
 315         }
 316         // All processes must have quit by now, but just in case...
 317         signals = sig_waitTimeout(SIG_USER0 | SIG_USER1 | SIG_USER2, 200);
 318         if (signals & (SIG_USER0 | SIG_USER1 | SIG_USER2))
 319         {
 320                 ret = -1;
 321                 goto out;
 322         }
 323         if (signals & SIG_TIMEOUT)
 324         {
 325                 kputs("Priority test successfull.\n");
 326         }
 327 out:
 328         proc_setPri(proc_current(), orig_pri);
 329         if (ret != 0)
 330                 kputs("Priority test failed.\n");
 331         return ret;
 332 }
 333 #endif /* CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI */
 334
 335 /**
 336  * Process scheduling test
 337  */
 338 int proc_testRun(void)
 339 {
 340 #if CONFIG_KERN_PREEMPT
 341         // Clear shared data (this is needed when this testcase is embedded in
 342         // the demo application).
 343         memset(preempt_counter, 0, sizeof(preempt_counter));
 344         memset(preempt_done, 0, sizeof(preempt_done));
 345         memset(barrier, 0, sizeof(barrier));
 346         main_barrier = 0;
 347 #endif /* CONFIG_KERN_PREEMPT */
 348         memset(done, 0, sizeof(done));
 349
 350         /* Start tests */
 351         worker_test();
 352 #if CONFIG_KERN_PREEMPT
 353         preempt_worker_test();
 354 #endif /* CONFIG_KERN_PREEMPT */
 355 #if CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI
 356         prio_worker_test();
 357 #endif /* CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI */
 358         return 0;
 359 }
 360
 361 int proc_testSetup(void)
 362 {
 363         kdbg_init();
 364
 365         kprintf("Init Timer..");
 366         timer_init();
 367         kprintf("Done.\n");
 368
 369         kprintf("Init Process..");
 370         proc_init();
 371         kprintf("Done.\n");
 372
 373         return 0;
 374 }
 375
 376 int proc_testTearDown(void)
 377 {
 378         kputs("TearDown Process test.\n");
 379         return 0;
 380 }
 381
 382 TEST_MAIN(proc);