// 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);