--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/personality/example/main.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1104 @@
+// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32test\personality\example\main.cpp
+// Test code for example RTOS personality.
+//
+//
+
+#include <kernel/kern_priv.h>
+#include <personality/example/personality.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define OC_TASK 0
+#define L2_TASK 1
+#define RR_TASK 2
+#define NONEXISTENT_TASK 3
+#define TM_TASK 4
+#define TASK1 6
+#define TASK2 7
+#define TASK3 8
+#define TASK4 9
+#define L1_TASK 10
+
+void oo_overall_control(void);
+void l1_task_entry(void);
+void l2_task_entry(void);
+void rr_task_entry(void);
+void tm_task_entry(void);
+void task1_entry(void);
+void task2_entry(void);
+void task3_entry(void);
+void task4_entry(void);
+
+typedef void (*isr_entry)(unsigned);
+
+extern int start_random_isr(isr_entry vector);
+extern void stop_random_isr(void);
+
+const taskinfo task_list[] =
+ {
+
+ /* entry_pt, priority, stack_size, task_id, auto_start */
+
+ { &oo_overall_control, 120, 1024, OC_TASK, 1 },
+ { &l2_task_entry, 236, 1024, L2_TASK, 0 },
+ { &rr_task_entry, 224, 1024, RR_TASK, 0 },
+ { &tm_task_entry, 240, 1024, TM_TASK, 0 },
+ { &task1_entry, 112, 1024, TASK1, 0 },
+ { &task2_entry, 112, 1024, TASK2, 0 },
+ { &task3_entry, 112, 1024, TASK3, 0 },
+ { &task4_entry, 112, 1024, TASK4, 0 },
+ { &l1_task_entry, 244, 1024, L1_TASK, 0 },
+ /* terminator */
+ { 0, 0, 0, 0, 0 }
+ };
+
+const poolinfo pool_list[] =
+ {
+ /* block size, block count */
+ { 32, 256 },
+ { 64, 256 },
+ { 128, 128 },
+ { 256, 64 },
+ { 512, 32 },
+ /* terminator */
+ { 0, 0 }
+ };
+
+const int timer_count = 8;
+const int semaphore_count = 2;
+
+#define TM_TIMER 0
+
+#define TM_INIT_DELAY 1000
+#define TM_PERIOD 2
+
+volatile unsigned next_random_id = 0;
+volatile unsigned random_sem_signal_interval = 0;
+volatile unsigned random_sem_signal_count = 0;
+volatile unsigned random_send_interval = 0;
+volatile unsigned random_send_count = 0;
+volatile unsigned tmcount = 0;
+volatile int t1func = 0;
+volatile int t2func = 0;
+volatile int t3func = 0;
+volatile int t4func = 0;
+
+#define TEST_SEM 0
+#define ISR_SEM 1
+
+#define MSG_ID_INIT 1
+#define MSG_ID_RUN 2
+#define MSG_ID_RUN_P 3
+#define MSG_ID_RND_ISR 4
+#define MSG_ID_DONE 5
+#define MSG_ID_DATA 6
+#define MSG_ID_FLUSH 7
+#define MSG_ID_SEM_RPT 8
+#define MSG_ID_RCV_RPT 9
+#define MSG_ID_TM_RPT 10
+
+typedef struct _run_msg
+ {
+ msghdr header;
+ int task_id;
+ unsigned tmcount;
+ int parameter;
+ } run_msg;
+
+typedef struct _random_isr_msg
+ {
+ msghdr header;
+ unsigned random_isr_number;
+ unsigned extra;
+ } random_isr_msg;
+
+typedef struct _data_msg
+ {
+ msghdr header;
+ int length;
+ unsigned char checksum;
+ unsigned char data[1];
+ } data_msg;
+
+typedef struct _report_msg
+ {
+ msghdr header;
+ int pad;
+ unsigned count;
+ unsigned ok_count;
+ unsigned bad_count;
+ } report_msg;
+
+void busy_wait(unsigned ticks)
+ {
+ unsigned t0 = tmcount;
+ while ((tmcount - t0) < ticks)
+ {}
+ }
+
+void send_run_signal()
+ {
+ run_msg* m = (run_msg*)alloc_mem_block(sizeof(run_msg));
+ assert(m);
+ m->header.msg_id = MSG_ID_RUN;
+ m->task_id = current_task_id();
+ m->tmcount = tmcount;
+ int r = send_msg(OC_TASK, &m->header);
+ assert(r == OK);
+ }
+
+void send_run_signal_p(int parameter)
+ {
+ run_msg* m = (run_msg*)alloc_mem_block(sizeof(run_msg));
+ assert(m);
+ m->header.msg_id = MSG_ID_RUN_P;
+ m->task_id = current_task_id();
+ m->tmcount = tmcount;
+ m->parameter = parameter;
+ int r = send_msg(OC_TASK, &m->header);
+ assert(r == OK);
+ }
+
+void tsend_run_signal_p(int task_id, int parameter)
+ {
+ run_msg* m = (run_msg*)alloc_mem_block(sizeof(run_msg));
+ assert(m);
+ m->header.msg_id = MSG_ID_RUN_P;
+ m->task_id = current_task_id();
+ m->tmcount = tmcount;
+ m->parameter = parameter;
+ int r = send_msg(task_id, &m->header);
+ assert(r == OK);
+ }
+
+void check_no_signal()
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, NO_WAIT);
+ assert(r == TIMED_OUT);
+ }
+
+unsigned check_for_signal(int task_id)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, NO_WAIT);
+ assert(r == OK);
+ assert(m->msg_id == MSG_ID_RUN);
+ run_msg* rm = (run_msg*)m;
+ assert(rm->task_id == task_id);
+ unsigned tmc = rm->tmcount;
+ free_mem_block(m);
+ return tmc;
+ }
+
+int check_for_signal_p(int task_id, int task_id2, unsigned* pt)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, NO_WAIT);
+ assert(r == OK);
+ assert(m->msg_id == MSG_ID_RUN_P);
+ run_msg* rm = (run_msg*)m;
+ assert(rm->task_id == task_id);
+ assert(m->sending_task_id == task_id2);
+ r = rm->parameter;
+ if (pt)
+ *pt = rm->tmcount;
+ free_mem_block(m);
+ return r;
+ }
+
+int wait_for_signal_p(int task_id, unsigned* pt)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ assert(m->msg_id == MSG_ID_RUN_P);
+ run_msg* rm = (run_msg*)m;
+ assert(rm->task_id == task_id);
+ r = rm->parameter;
+ if (pt)
+ *pt = rm->tmcount;
+ free_mem_block(m);
+ return r;
+ }
+
+void resume_4(int t1, int t2, int t3, int t4)
+ {
+ if (t1>=0)
+ assert(resume_task(t1)==OK);
+ if (t2>=0)
+ assert(resume_task(t2)==OK);
+ if (t3>=0)
+ assert(resume_task(t3)==OK);
+ if (t4>=0)
+ assert(resume_task(t4)==OK);
+ }
+
+void check_signal_4(int t1, int t2, int t3, int t4)
+ {
+ if (t1>=0)
+ check_for_signal(t1);
+ else
+ check_no_signal();
+ if (t2>=0)
+ check_for_signal(t2);
+ else
+ check_no_signal();
+ if (t3>=0)
+ check_for_signal(t3);
+ else
+ check_no_signal();
+ if (t4>=0)
+ check_for_signal(t4);
+ else
+ check_no_signal();
+ }
+
+void check_for_multiple_signals(int task_id, int count)
+ {
+ unsigned t = check_for_signal(task_id);
+ while (--count)
+ {
+ unsigned t2 = check_for_signal(task_id);
+ assert(t2 - t >= 1);
+ t = t2;
+ }
+ }
+
+int flush_signals(void)
+ {
+ int c = 0;
+ for (;;)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, NO_WAIT);
+ if (r == TIMED_OUT)
+ break;
+ assert(r == OK);
+ assert(m->msg_id == MSG_ID_RUN);
+ free_mem_block(m);
+ ++c;
+ }
+ return c;
+ }
+
+void test_mem_pool(size_t size, int count, void** chain)
+ {
+ int i, fill;
+ void *b, *bb, *c;
+ c = *chain;
+ for (i=0; i<count; ++i)
+ {
+ b = alloc_mem_block(size);
+ assert(b != NULL);
+ fill = (int)(size>>5);
+ fill += 29;
+ fill *= fill;
+ fill &= 0xff;
+ memset(b, fill, size);
+ *(void**)b = c;
+ ((int*)b)[1] = (int)size;
+ c = b;
+ }
+ bb = alloc_mem_block(size);
+ assert(bb == NULL);
+ *chain = c;
+ }
+
+void check_blocks(void* chain)
+ {
+ void* p = chain;
+ while (p)
+ {
+ unsigned char *q, *qq;
+ int size, fill, x;
+ size = ((int*)p)[1];
+ fill = (size>>5)+29;
+ fill = (fill*fill)&0xff;
+ q = (unsigned char*)p + sizeof(void*) + sizeof(int);
+ qq = (unsigned char*)p + size;
+ x = 0;
+ while (q<qq)
+ x |= (*q++ ^ fill);
+ assert(x==0);
+ p = *(void**)p;
+ }
+ }
+
+int free_blocks(void* chain)
+ {
+ void* p = chain;
+ int c = 0;
+ while (p)
+ {
+ void* n = *(void**)p;
+ free_mem_block(p);
+ p = n;
+ ++c;
+ }
+ return c;
+ }
+
+void test_mem_mgr(void)
+ {
+ void* chain = NULL;
+ const poolinfo* pi = pool_list;
+ int nblocks = 0;
+ int nfreed = 0;
+ for (; pi->block_size; ++pi)
+ {
+ nblocks += pi->block_count;
+ test_mem_pool(pi->block_size, pi->block_count, &chain);
+ }
+ check_blocks(chain);
+ nfreed = free_blocks(chain);
+ assert(nfreed == nblocks);
+ chain = NULL;
+ for (--pi; pi >= pool_list; --pi)
+ test_mem_pool(pi->block_size, pi->block_count, &chain);
+ check_blocks(chain);
+ nfreed = free_blocks(chain);
+ assert(nfreed == nblocks);
+ chain = NULL;
+ kprintf("Memory Manager Test OK");
+ }
+
+void test_suspend_1(void)
+ {
+ unsigned t1, t2, t3;
+ int r;
+ t1 = tmcount;
+ delay(5*TM_PERIOD);
+ t2 = tmcount;
+ assert( ((int)t2)-((int)t1) >= 5 );
+ r = suspend_task(TM_TASK);
+ assert(r == OK);
+ t1 = tmcount;
+ delay(5*TM_PERIOD);
+ t2 = tmcount;
+ assert(t2==t1);
+ r = resume_task(TM_TASK);
+ assert(r == OK);
+ t3 = tmcount;
+ assert( ((int)t3)-((int)t2) >= 5 );
+
+ r = suspend_task(TM_TASK);
+ assert(r == OK);
+ r = suspend_task(TM_TASK);
+ assert(r == OK);
+ t1 = tmcount;
+ delay(5*TM_PERIOD);
+ t2 = tmcount;
+ assert(t2==t1);
+ r = resume_task(TM_TASK);
+ assert(r == OK);
+ t3 = tmcount;
+ assert(t3==t2);
+ r = resume_task(TM_TASK);
+ assert(r == OK);
+ t3 = tmcount;
+ assert( ((int)t3)-((int)t2) >= 5 );
+
+ r = suspend_task(-1);
+ assert(r == BAD_TASK_ID);
+ r = suspend_task(300);
+ assert(r == BAD_TASK_ID);
+ r = suspend_task(NONEXISTENT_TASK);
+ assert(r == BAD_TASK_ID);
+ r = resume_task(-1);
+ assert(r == BAD_TASK_ID);
+ r = resume_task(300);
+ assert(r == BAD_TASK_ID);
+ r = resume_task(NONEXISTENT_TASK);
+ assert(r == BAD_TASK_ID);
+
+ kprintf("test_suspend_1 OK");
+ }
+
+void test_priority_scheduling(void)
+ {
+ int init_pri = get_task_priority(current_task_id());
+ resume_4(TASK1, TASK2, TASK3, TASK4);
+ delay(80*TM_PERIOD);
+ check_for_multiple_signals(TASK1, 50); // check no timeslicing
+ assert(flush_signals()<=31);
+ suspend_task(TASK1);
+ delay(80*TM_PERIOD);
+ check_for_multiple_signals(TASK2, 50); // check no timeslicing
+ assert(flush_signals()<=31);
+ suspend_task(TASK2);
+ delay(80*TM_PERIOD);
+ check_for_multiple_signals(TASK3, 50); // check no timeslicing
+ assert(flush_signals()<=31);
+ suspend_task(TASK3);
+ delay(1);
+ check_for_signal(TASK4);
+ assert(flush_signals()<=1);
+
+ t1func = 1;
+ t2func = 1;
+ t3func = 1;
+ t4func = 1;
+
+ resume_4(TASK1, TASK2, TASK3, TASK4);
+ delay(10);
+ flush_signals();
+
+ resume_4(TASK3, TASK2, TASK4, TASK1);
+ delay(10);
+ check_signal_4(TASK3, TASK2, TASK4, TASK1);
+ check_no_signal();
+ resume_4(TASK1, TASK2, TASK3, TASK4);
+ check_no_signal(); // all lower priority so don't run
+ set_task_priority(TASK2, 255); // higher than current task so run immediately
+ check_for_signal(TASK2);
+ set_task_priority(TASK4, 116);
+ check_no_signal(); // all lower priority so don't run
+ delay(10);
+ check_for_signal(TASK4);
+ check_for_signal(TASK1);
+ check_for_signal(TASK3);
+ set_task_priority(TASK1, 116);
+ set_task_priority(TASK2, 116);
+ set_task_priority(TASK3, 116);
+ set_task_priority(TASK4, 116);
+ resume_4(TASK1, TASK2, TASK3, TASK4);
+ set_task_priority(current_task_id(), 112); // drop current task priority
+ assert(get_task_priority(current_task_id())==112);
+ check_signal_4(TASK1, TASK2, TASK3, TASK4);
+ set_task_priority(current_task_id(), init_pri);
+ assert(get_task_priority(current_task_id())==init_pri);
+
+ kprintf("test_priority_scheduling OK");
+ }
+
+unsigned sem_test(int task_id)
+ {
+ int r = semaphore_signal(TEST_SEM);
+ assert(r==OK);
+ return check_for_signal(task_id);
+ }
+
+unsigned sem_test_p(int task_id, int parameter)
+ {
+ unsigned t;
+ int r = semaphore_signal(TEST_SEM);
+ assert(r==OK);
+ r = check_for_signal_p(task_id, task_id, &t);
+ assert(r == parameter);
+ return t;
+ }
+
+unsigned sem_test_pt(int task_id, int parameter)
+ {
+ unsigned t;
+ int r = semaphore_signal(TEST_SEM);
+ assert(r==OK);
+ r = check_for_signal_p(task_id, task_id, &t);
+ assert(r == parameter);
+ return t;
+ }
+
+void test_semaphore(void)
+ {
+ unsigned t1, t2, t3;
+ int r;
+ int init_pri = get_task_priority(current_task_id());
+ set_task_priority(TASK1, 128);
+ set_task_priority(TASK2, 128);
+ set_task_priority(TASK3, 128);
+ set_task_priority(TASK4, 128);
+ t1func = 2;
+ t2func = 2;
+ t3func = 2;
+ t4func = 2;
+ resume_4(TASK1, TASK2, TASK3, TASK4);
+ delay(10); // let tasks wait on semaphore
+ check_no_signal();
+ sem_test(TASK1); // test they are released in same order
+ sem_test(TASK2);
+ sem_test(TASK3);
+ sem_test(TASK4);
+ check_no_signal();
+ set_task_priority(TASK3, 132); // test highest priority is released first
+ sem_test(TASK3);
+ sem_test(TASK3);
+ suspend_task(TASK3); // test suspended task doesn't contend for semaphore
+ sem_test(TASK1);
+ sem_test(TASK2);
+ sem_test(TASK4);
+ sem_test(TASK1);
+ suspend_task(TASK2);
+ sem_test(TASK4);
+ sem_test(TASK1);
+ sem_test(TASK4);
+ set_task_priority(TASK2, 136); // change priority while suspended
+ sem_test(TASK1);
+ sem_test(TASK4);
+ sem_test(TASK1);
+ resume_task(TASK2);
+ sem_test(TASK2);
+ sem_test(TASK2); // test new highest priority task acquires semaphore first
+ delay(100*TM_PERIOD);
+ check_no_signal(); // check waits don't time out
+
+ t2func = 3; // switch over to timed waits for task 2
+ t1 = sem_test(TASK2); // get one last message of previous type
+ delay(5*TM_PERIOD);
+ t2 = sem_test_p(TASK2, OK); // signal after half the timeout and check OK
+ delay(11*TM_PERIOD); // wait for > timeout
+ r = check_for_signal_p(TASK2, TASK2, &t3);
+ assert(r == TIMED_OUT);
+ kprintf("t2-t1=%d t3-t2=%d", t2-t1, t3-t2);
+ assert(t2-t1 >= 5);
+ assert(t3-t2 >= 10);
+ sem_test_p(TASK2, OK);
+ resume_task(TASK3);
+
+ set_task_priority(current_task_id(), 176); // raise current task priority
+ semaphore_signal(TEST_SEM); // signal semaphore 4 times - should release all 4 waiting threads
+ semaphore_signal(TEST_SEM);
+ semaphore_signal(TEST_SEM);
+ semaphore_signal(TEST_SEM);
+ set_task_priority(current_task_id(), init_pri); // let tasks run
+ r = check_for_signal_p(TASK2, TASK2, NULL);
+ assert(r == OK);
+ check_for_signal(TASK3);
+ check_for_signal(TASK4);
+ check_for_signal(TASK1);
+ set_task_priority(current_task_id(), 176); // raise current task priority
+ busy_wait(11); // let semaphore wait time out
+ t1func = 4; // switch all threads over
+ t2func = 4; //
+ t3func = 4; //
+ t4func = 4; //
+ semaphore_signal(TEST_SEM); // signal semaphore 3 times - should release other 3 waiting threads
+ semaphore_signal(TEST_SEM);
+ semaphore_signal(TEST_SEM);
+ set_task_priority(current_task_id(), init_pri); // let tasks run
+ r = check_for_signal_p(TASK2, TASK2, NULL);
+ assert(r == TIMED_OUT);
+ check_for_signal(TASK3);
+ check_for_signal(TASK4);
+ check_for_signal(TASK1);
+
+ kprintf("test_semaphore OK");
+ }
+
+void test_message_queue(void)
+ {
+ unsigned t1, t2, t3, t4;
+ int tid, p, r;
+ int init_pri = get_task_priority(current_task_id());
+ p = 0;
+ t1 = 0;
+ for (tid = TASK1; tid <= TASK4; ++tid)
+ {
+ for (p = 1; p; p<<=1)
+ {
+ tsend_run_signal_p(tid, p);
+ r = check_for_signal_p(OC_TASK, tid, NULL);
+ assert(r == p);
+ }
+ }
+ check_no_signal();
+ set_task_priority(current_task_id(), 176); // raise current task priority
+ set_task_priority(TASK4, 144); // change task priorities while they are waiting
+ set_task_priority(TASK3, 140);
+ set_task_priority(TASK2, 136);
+ set_task_priority(TASK1, 132);
+ t1func = 5; // switch task 1 to timed waits
+ for (tid = TASK1; tid <= TASK4; ++tid)
+ {
+ for (p = 0; p<0x40000000; p+=(0x413b9cb+tid))
+ {
+ tsend_run_signal_p(tid, p); // let multiple messages accumulate on the queues
+ }
+ }
+ check_no_signal();
+ set_task_priority(current_task_id(), init_pri); // let tasks run
+ kprintf("init_pri=%d",init_pri);
+ for (tid = TASK4; tid >= TASK1; --tid)
+ {
+ for (p = 0; p<0x40000000; p+=(0x413b9cb+tid))
+ {
+ r = check_for_signal_p(OC_TASK, tid, &t1);
+ assert(r == p);
+ }
+ }
+
+ delay(5*TM_PERIOD);
+ tsend_run_signal_p(TASK1, p); // send after half timeout
+ r = check_for_signal_p(OC_TASK, TASK1, &t2);
+ assert(r == p);
+ delay(11*TM_PERIOD); // wait for > timeout
+ tsend_run_signal_p(TASK1, ~p); // send after timeout
+ r = check_for_signal_p(TASK1, TASK1, &t3);
+ assert(r == TIMED_OUT);
+ kprintf("t2-t1=%d t3-t2=%d", t2-t1, t3-t2);
+ assert(t2-t1 >= 5);
+ assert(t3-t2 >= 10);
+ r = check_for_signal_p(OC_TASK, TASK1, &t4);
+ assert(r == ~p);
+ assert(t4-t3 <= 1);
+ t1func = 6; // switch task 1 to timed semaphore wait
+ t2func = 7; // switch task 2 to timed queue wait
+ t3func = 8; //
+ t4func = 8; //
+ for (tid = TASK1; tid <= TASK4; ++tid)
+ {
+ tsend_run_signal_p(tid, 0);
+ r = check_for_signal_p(OC_TASK, tid, NULL);
+ assert(r == 0);
+ }
+ check_no_signal();
+
+ kprintf("test_message_queue OK");
+ }
+
+void random_isr(unsigned n)
+ {
+ random_isr_msg* m;
+ unsigned extra = 1;
+ unsigned count = 1;
+ int r;
+ if (!(n%11))
+ ++count;
+ if (!(n%13))
+ ++count;
+ while (count--)
+ {
+ m = (random_isr_msg*)alloc_mem_block(sizeof(random_isr_msg));
+ m->header.msg_id = MSG_ID_RND_ISR;
+ m->random_isr_number = n;
+ extra *= n;
+ m->extra = extra;
+ r = send_msg(L1_TASK, &m->header);
+ }
+ if (random_sem_signal_count && !--random_sem_signal_count)
+ {
+ random_sem_signal_count = random_sem_signal_interval;
+ semaphore_signal(ISR_SEM);
+ }
+ }
+
+void flush_queue(msghdr** f, msghdr** l, msghdr* tm)
+ {
+ msghdr* m = *f;
+ *f = NULL;
+ *l = NULL;
+ send_to_epoc(tm);
+ while (m)
+ {
+ msghdr* n = m->next;
+ send_to_epoc(m);
+ m = n;
+ }
+ }
+
+void l1_task_entry(void)
+ {
+ msghdr* first = NULL;
+ msghdr* last = NULL;
+ unsigned state = 0;
+ unsigned extra_count = 0;
+ unsigned extra_value = 0;
+ assert(current_task_id() == L1_TASK);
+ kprintf("L1_TASK running");
+ for (;;)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ switch (m->msg_id)
+ {
+ case MSG_ID_RND_ISR:
+ {
+ random_isr_msg* rm = (random_isr_msg*)m;
+ assert(m->sending_task_id == TASK_ID_ISR);
+ assert(rm->random_isr_number == next_random_id);
+ if (state == 0)
+ {
+ extra_count = 0;
+ if (!(next_random_id % 11))
+ ++extra_count;
+ if (!(next_random_id % 13))
+ ++extra_count;
+ extra_value = next_random_id;
+ }
+ else if (state > 0)
+ {
+ extra_value *= next_random_id;
+ }
+ assert(rm->extra == extra_value);
+ if (++state > extra_count)
+ state = 0;
+ if (state == 0)
+ ++next_random_id;
+ if (rm->random_isr_number == 0)
+ send_msg(OC_TASK, m), m=NULL;
+ if (state == 1 && extra_count == 2 && m)
+ {
+ flush_queue(&first, &last, m);
+ m = NULL;
+ }
+ if (random_send_count && !--random_send_count)
+ {
+ random_send_count = random_send_interval;
+ if (m)
+ send_msg(TASK2, m), m=NULL;
+ }
+ break;
+ }
+ case MSG_ID_DATA:
+ m->next = NULL;
+ if (last)
+ last->next = m;
+ else
+ first = m;
+ last = m;
+ m = NULL;
+ break;
+ case MSG_ID_FLUSH:
+ flush_queue(&first, &last, m);
+ m = NULL;
+ break;
+ default:
+ kprintf("L1<-%08x",m->msg_id);
+ break;
+ }
+ if (m)
+ free_mem_block(m);
+ }
+ }
+
+void l2_task_entry(void)
+ {
+ assert(current_task_id() == L2_TASK);
+ kprintf("L2_TASK running");
+ for (;;)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ switch (m->msg_id)
+ {
+ case MSG_ID_DATA:
+ {
+ data_msg* dm = (data_msg*)m;
+ int i;
+ unsigned char cs = 0;
+ for (i=0; i<dm->length; ++i)
+ cs = (unsigned char)(cs + dm->data[i]);
+ dm->checksum = cs;
+ send_msg(L1_TASK, m);
+ m=NULL;
+ break;
+ }
+ default:
+ kprintf("L2<-%08x",m->msg_id);
+ break;
+ }
+ if (m)
+ free_mem_block(m);
+ }
+ }
+
+void rr_task_entry(void)
+ {
+ assert(current_task_id() == RR_TASK);
+ kprintf("RR_TASK running");
+ for (;;)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ switch (m->msg_id)
+ {
+ case MSG_ID_DATA:
+ send_msg(L2_TASK, m);
+ m=NULL;
+ break;
+ default:
+ kprintf("RR<-%08x",m->msg_id);
+ break;
+ }
+ if (m)
+ free_mem_block(m);
+ }
+ }
+
+void tm_task_entry(void)
+ {
+ assert(current_task_id() == TM_TASK);
+ kprintf("TM_TASK running");
+ for (;;)
+ {
+ msghdr* m = NULL;
+ int r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ switch (m->msg_id)
+ {
+ case MSG_ID_TIMEOUT:
+ tmcount = ((timer_msg*)m)->count;
+ assert(m->sending_task_id == TASK_ID_ISR);
+ if (!(tmcount & 255))
+ {
+ report_msg* rpt = (report_msg*)alloc_mem_block(sizeof(report_msg));
+ rpt->header.msg_id = MSG_ID_TM_RPT;
+ rpt->count = tmcount;
+ rpt->ok_count = 0;
+ rpt->bad_count = 0;
+ send_to_epoc(&rpt->header);
+ }
+ break;
+ default:
+ kprintf("TM<-%08x",m->msg_id);
+ break;
+ }
+ free_mem_block(m);
+ }
+ }
+
+void generic_task(volatile int* f)
+ {
+ int r;
+ msghdr* m;
+ unsigned t1, t2;
+ unsigned count = 0;
+ unsigned ok_count = 0;
+ unsigned bad_count = 0;
+ while (*f==0)
+ {
+ send_run_signal();
+ busy_wait(1);
+ }
+ while (*f==1)
+ {
+ send_run_signal();
+ suspend_task(current_task_id());
+ }
+ while (*f==2)
+ {
+ r = semaphore_wait(TEST_SEM, WAIT_FOREVER);
+ assert(r == OK);
+ send_run_signal();
+ }
+ while (*f==3)
+ {
+ r = semaphore_wait(TEST_SEM, 10*TM_PERIOD);
+ assert(r==OK || r==TIMED_OUT);
+ send_run_signal_p(r);
+ }
+ while (*f==4)
+ {
+ r = recv_msg(&m, WAIT_FOREVER);
+ assert(r==OK);
+ assert(m->sending_task_id == OC_TASK);
+ r = send_msg(OC_TASK, m);
+ assert(r == OK);
+ }
+ while (*f==5)
+ {
+ r = recv_msg(&m, 10*TM_PERIOD);
+ assert(r==OK || r==TIMED_OUT);
+ if (r == OK)
+ {
+ assert(m->sending_task_id == OC_TASK);
+ r = send_msg(OC_TASK, m);
+ assert(r == OK);
+ }
+ else
+ send_run_signal_p(r);
+ }
+ while (*f==6)
+ {
+ t1 = tick_count();
+ r = semaphore_wait(ISR_SEM, 5);
+ t2 = tick_count() - t1;
+ if (r == TIMED_OUT && t2<5)
+ {
+ kprintf("SEM timed out too soon: %d", t2);
+ ++bad_count;
+ }
+ if (r == OK)
+ ++ok_count;
+ ++count;
+ if (!(count & 0xff))
+ {
+ report_msg* rpt = (report_msg*)alloc_mem_block(sizeof(report_msg));
+ rpt->header.msg_id = MSG_ID_SEM_RPT;
+ rpt->count = count;
+ rpt->ok_count = ok_count;
+ rpt->bad_count = bad_count;
+ send_to_epoc(&rpt->header);
+ }
+ }
+ while (*f==7)
+ {
+ t1 = tick_count();
+ r = recv_msg(&m, 5);
+ t2 = tick_count() - t1;
+ if (r == TIMED_OUT && t2<5)
+ {
+ kprintf("RECV timed out too soon: %d", t2);
+ ++bad_count;
+ }
+ if (r==OK)
+ ++ok_count, free_mem_block(m);
+ ++count;
+ if (!(count & 0xff))
+ {
+ report_msg* rpt = (report_msg*)alloc_mem_block(sizeof(report_msg));
+ rpt->header.msg_id = MSG_ID_RCV_RPT;
+ rpt->count = count;
+ rpt->ok_count = ok_count;
+ rpt->bad_count = bad_count;
+ send_to_epoc(&rpt->header);
+ }
+ }
+ kprintf("Task %d finished", current_task_id());
+ for(;;)
+ suspend_task(current_task_id());
+ }
+
+void task1_entry(void)
+ {
+ assert(current_task_id() == TASK1);
+ generic_task(&t1func);
+ }
+
+void task2_entry(void)
+ {
+ assert(current_task_id() == TASK2);
+ generic_task(&t2func);
+ }
+
+void task3_entry(void)
+ {
+ assert(current_task_id() == TASK3);
+ generic_task(&t3func);
+ }
+
+void task4_entry(void)
+ {
+ assert(current_task_id() == TASK4);
+ generic_task(&t4func);
+ }
+
+
+
+void oo_overall_control(void)
+ {
+ int r;
+ msghdr* m;
+ random_isr_msg* rm;
+ unsigned t1, t2, rss_interval;
+ kprintf("OC_TASK running");
+ assert(current_task_id() == OC_TASK);
+ resume_task(L2_TASK);
+ resume_task(RR_TASK);
+ resume_task(TM_TASK);
+ test_mem_mgr();
+
+ kprintf("Wait for init msg");
+ r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ assert(m->msg_id == MSG_ID_INIT);
+ assert(m->sending_task_id == TASK_ID_UNKNOWN);
+ free_mem_block(m);
+ kprintf("Received init msg");
+
+ r = start_periodic_timer(TM_TIMER, TM_TASK, TM_INIT_DELAY, TM_PERIOD, NULL);
+ assert(r == OK);
+ delay(TM_INIT_DELAY-10);
+ assert(tmcount == 0);
+ delay(10*TM_PERIOD+20);
+ assert(tmcount > 0);
+ test_suspend_1();
+ test_priority_scheduling();
+ test_semaphore();
+ test_message_queue();
+
+ resume_task(L1_TASK);
+ r = start_random_isr(&random_isr);
+ if (r != OK)
+ goto no_random_isr;
+
+ r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ assert(m->msg_id == MSG_ID_RND_ISR);
+ assert(m->sending_task_id == L1_TASK);
+ rm = (random_isr_msg*)m;
+ assert(rm->random_isr_number == 0);
+ free_mem_block(m);
+ t1 = next_random_id;
+ delay(1024);
+ t2 = next_random_id;
+ kprintf("%d random ISRs in 1024 ticks", t2-t1);
+ rss_interval = (5*(t2-t1)+512)/1024;
+ set_task_priority(TASK1, 196); // needs to be higher than DfcThread1
+ set_task_priority(TASK2, 196);
+ random_sem_signal_interval = rss_interval;
+ random_sem_signal_count = rss_interval;
+ random_send_interval = rss_interval;
+ random_send_count = rss_interval;
+
+no_random_isr:
+ m = (msghdr*)alloc_mem_block(sizeof(msghdr));
+ m->msg_id = MSG_ID_DONE;
+ send_to_epoc(m);
+ kprintf("All tests completed OK");
+ for (;;)
+ {
+ int r = recv_msg(&m, WAIT_FOREVER);
+ assert(r == OK);
+ switch (m->msg_id)
+ {
+ case MSG_ID_DATA:
+ send_msg(RR_TASK, m);
+ m=NULL;
+ break;
+ case MSG_ID_FLUSH:
+ send_msg(L1_TASK, m);
+ m=NULL;
+ break;
+ case MSG_ID_DONE:
+ stop_random_isr();
+ stop_timer(TM_TIMER);
+ suspend_task(L1_TASK);
+ suspend_task(L2_TASK);
+ suspend_task(RR_TASK);
+ suspend_task(TM_TASK);
+ suspend_task(TASK1);
+ suspend_task(TASK2);
+ suspend_task(TASK3);
+ suspend_task(TASK4);
+ break;
+ default:
+ kprintf("OC<-%08x",m->msg_id);
+ break;
+ }
+ if (m)
+ free_mem_block(m);
+ }
+ }
+
+#ifdef __cplusplus
+}
+#endif