X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fkern%2Fproc_test.c;h=ad30f711153ca120e232b18336e5afd300555d9f;hb=47dfe44ebab1698c1dee6757b6ce0f19b5e030a3;hp=38a6b16c66fe5083b9b41e1ce8c2ab95179a354a;hpb=87302355709b6d5ac0592024b84207ba86baa82e;p=bertos.git diff --git a/bertos/kern/proc_test.c b/bertos/kern/proc_test.c index 38a6b16c..ad30f711 100644 --- a/bertos/kern/proc_test.c +++ b/bertos/kern/proc_test.c @@ -26,103 +26,247 @@ * invalidate any other reasons why the executable file might be covered by * the GNU General Public License. * - * Copyright 2005 Develer S.r.l. (http://www.develer.com/) + * Copyright 2008 Develer S.r.l. (http://www.develer.com/) * --> * * * \brief Test kernel process. * * \version $Id$ - * * \author Daniele Basile + * + * $test$: cp bertos/cfg/cfg_proc.h $cfgdir/ + * $test$: echo "#undef CONFIG_KERN" >> $cfgdir/cfg_proc.h + * $test$: echo "#define CONFIG_KERN 1" >> $cfgdir/cfg_proc.h + * $test$: echo "#undef CONFIG_KERN_PRI" >> $cfgdir/cfg_proc.h + * $test$: echo "#define CONFIG_KERN_PRI 1" >> $cfgdir/cfg_proc.h + * $test$: cp bertos/cfg/cfg_monitor.h $cfgdir/ + * $test$: echo "#undef CONFIG_KERN_MONITOR" >> $cfgdir/cfg_monitor.h + * $test$: echo "#define CONFIG_KERN_MONITOR 1" >> $cfgdir/cfg_monitor.h + * $test$: cp bertos/cfg/cfg_signal.h $cfgdir/ + * $test$: echo "#undef CONFIG_KERN_SIGNALS" >> $cfgdir/cfg_signal.h + * $test$: echo "#define CONFIG_KERN_SIGNALS 1" >> $cfgdir/cfg_signal.h */ #include +#include +#include + #include #include -/* - * Proc scheduling test subthread 1 - */ -static void proc_test1(void) -{ - for (int i = 0; i < 30; ++i) - { - kputs("> test1\n"); - timer_delay(50); - proc_switch(); - } -} + +// Global settings for the test. +#define DELAY 5 + +// Settings for the test process. +//Process 1 +#define INC_PROC_T1 1 +#define DELAY_PROC_T1 INC_PROC_T1*DELAY +//Process 2 +#define INC_PROC_T2 3 +#define DELAY_PROC_T2 INC_PROC_T2*DELAY +//Process 3 +#define INC_PROC_T3 5 +#define DELAY_PROC_T3 INC_PROC_T3*DELAY +//Process 4 +#define INC_PROC_T4 7 +#define DELAY_PROC_T4 INC_PROC_T4*DELAY +//Process 5 +#define INC_PROC_T5 11 +#define DELAY_PROC_T5 INC_PROC_T5*DELAY +//Process 6 +#define INC_PROC_T6 13 +#define DELAY_PROC_T6 INC_PROC_T6*DELAY +//Process 7 +#define INC_PROC_T7 17 +#define DELAY_PROC_T7 INC_PROC_T7*DELAY +//Process 8 +#define INC_PROC_T8 19 +#define DELAY_PROC_T8 INC_PROC_T8*DELAY + +//Global count for each process. +unsigned int t1_count = 0; +unsigned int t2_count = 0; +unsigned int t3_count = 0; +unsigned int t4_count = 0; +unsigned int t5_count = 0; +unsigned int t6_count = 0; +unsigned int t7_count = 0; +unsigned int t8_count = 0; /* - * Proc scheduling test subthread 2 + * These macros generate the code needed to create the test process functions. */ -static void proc_test2(void) -{ - for (int i = 0; i < 30; ++i) - { - kputs("> test2\n"); - timer_delay(75); - proc_switch(); - } +#define PROC_TEST(num) static void proc_test##num(void) \ +{ \ + for (int i = 0; i < INC_PROC_T##num; ++i) \ + { \ + t##num##_count++; \ + kputs("> Process[" #num "]\n"); \ + timer_delay(DELAY_PROC_T##num); \ + } \ } -static cpustack_t proc_test1_stack[CONFIG_PROC_DEFSTACKSIZE / sizeof(cpustack_t)]; -static cpustack_t proc_test2_stack[CONFIG_PROC_DEFSTACKSIZE / sizeof(cpustack_t)]; +#define PROC_TEST_STACK(num) PROC_DEFINE_STACK(proc_test##num##_stack, KERN_MINSTACKSIZE); +#define PROC_TEST_INIT(num) proc_new(proc_test##num, NULL, sizeof(proc_test##num##_stack), proc_test##num##_stack); +// Define process +PROC_TEST(1) +PROC_TEST(2) +PROC_TEST(3) +PROC_TEST(4) +PROC_TEST(5) +PROC_TEST(6) +PROC_TEST(7) +PROC_TEST(8) -int proc_testSetup(void) -{ - kdbg_init(); - proc_init(); - IRQ_ENABLE; - timer_init(); - return 0; -} +// Define process stacks for test. +PROC_TEST_STACK(1) +PROC_TEST_STACK(2) +PROC_TEST_STACK(3) +PROC_TEST_STACK(4) +PROC_TEST_STACK(5) +PROC_TEST_STACK(6) +PROC_TEST_STACK(7) +PROC_TEST_STACK(8) -int proc_testTearDown(void) -{ - return 0; +// Define params to test priority +#define PROC_PRI_TEST(num) static void proc_pri_test##num(void) \ +{ \ + struct Process *main_proc = (struct Process *) proc_currentUserData(); \ + kputs("> Process: " #num "\n"); \ + sig_signal(main_proc, SIG_USER##num); \ } +// Default priority is 0 +#define PROC_PRI_TEST_INIT(num, proc) \ +do { \ + struct Process *p = proc_new(proc_pri_test##num, (proc), sizeof(proc_test##num##_stack), proc_test##num##_stack); \ + proc_setPri(p, num + 1); \ +} while (0) + +PROC_TEST_STACK(0) +PROC_PRI_TEST(0) +PROC_PRI_TEST(1) +PROC_PRI_TEST(2) + + /** * Process scheduling test */ int proc_testRun(void) { - proc_new(proc_test1, NULL, sizeof(proc_test1_stack), proc_test1_stack); - proc_new(proc_test2, NULL, sizeof(proc_test2_stack), proc_test2_stack); - kputs("Processes created\n"); - - //kputs("stack1:\n"); - //kdump(proc_test_stack1 + sizeof(proc_test_stack1) - 64, 64); + int ret_value = 0; + kprintf("Run Process test..\n"); - //kputs("stack2:\n"); - //kdump(proc_test_stack2 + sizeof(proc_test_stack2) - 64, 64); + //Init the process tests + PROC_TEST_INIT(1) + PROC_TEST_INIT(2) + PROC_TEST_INIT(3) + PROC_TEST_INIT(4) + PROC_TEST_INIT(5) + PROC_TEST_INIT(6) + PROC_TEST_INIT(7) + PROC_TEST_INIT(8) + kputs("> Main: Processes created\n"); for (int i = 0; i < 30; ++i) { - kputs("> main\n"); + kputs("> Main\n"); timer_delay(93); - proc_switch(); + monitor_report(); + } + + if( t1_count == INC_PROC_T1 && + t2_count == INC_PROC_T2 && + t3_count == INC_PROC_T3 && + t4_count == INC_PROC_T4 && + t5_count == INC_PROC_T5 && + t6_count == INC_PROC_T6 && + t7_count == INC_PROC_T7 && + t8_count == INC_PROC_T8) + { + kputs("> Main: process test finished..ok!\n"); + ret_value = 0; + } + else + { + kputs("> Main: process test..fail!\n"); + ret_value = -1; + } + +#if CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI + // test process priority + // main process must have the higher priority to check signals received + proc_setPri(proc_current(), 10); + + struct Process *curr = proc_current(); + // the order in which the processes are created is important! + PROC_PRI_TEST_INIT(0, curr); + PROC_PRI_TEST_INIT(1, curr); + PROC_PRI_TEST_INIT(2, curr); + + // signals must be: USER2, 1, 0 in order + sigmask_t signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2); + if (!(signals & SIG_USER2)) + goto priority_fail; + + signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2); + if (!(signals & SIG_USER1)) + goto priority_fail; + + signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2); + if (!(signals & SIG_USER0)) + goto priority_fail; + + // All processes must have quit by now, but just in case... + signals = sig_waitTimeout(SIG_USER0 | SIG_USER1 | SIG_USER2, 200); + if (signals & (SIG_USER0 | SIG_USER1 | SIG_USER2)) + goto priority_fail; + + if (signals & SIG_TIMEOUT) + { + kputs("Priority test successfull.\n"); } + + return ret_value; + +priority_fail: + kputs("Priority test failed.\n"); + return -1; + +#endif + + return ret_value; + +} + +int proc_testSetup(void) +{ + kdbg_init(); + + #if CONFIG_KERN_PREEMPT + kprintf("Init Interrupt (preempt mode).."); + irq_init(); + kprintf("Done.\n"); + #endif + + kprintf("Init Timer.."); + timer_init(); + kprintf("Done.\n"); + + kprintf("Init Process.."); + proc_init(); + kprintf("Done.\n"); + + return 0; +} + +int proc_testTearDown(void) +{ + kputs("TearDown Process test.\n"); return 0; } -#warning Fix test to comply to new policy. -#if 0 -/* - * FIXME: to be compiled as a single file - * the kernel module needs the assembly switch function - * and the idle() that lay in a emulator cpp file. - * How can we fix this? - */ -#include TEST_ONLY(drv/kdebug.c) -#include TEST_ONLY(kern/coop.c) -#include TEST_ONLY(kern/proc.c) -#include TEST_ONLY(drv/timer.c) -#include TEST_ONLY(mware/formatwr.c) -#include TEST_ONLY(mware/hex.c) -#include TEST_ONLY(os/hptime.c) TEST_MAIN(proc); -#endif