/**
 * \file
 * <!--
 * This file is part of BeRTOS.
 *
 * Bertos is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 *
 * Copyright 2009 Develer S.r.l. (http://www.develer.com/)
 * -->
 *
 *
 * \brief Test kernel preemption.
 *
 * This testcase spawns TASKS parallel threads that runs for TIME seconds. They
 * continuously spin updating a global counter (one counter for each thread).
 *
 * At exit each thread checks if the others have been che chance to update
 * their own counter. If not, it means the preemption didn't occur and the
 * testcase returns an error message.
 *
 * Otherwise, if all the threads have been able to update their own counter it
 * means preemption successfully occurs, since there is no active sleep inside
 * each thread's implementation.
 *
 * \author Andrea Righi <arighi@develer.com>
 *
 * $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$: echo  "#undef CONFIG_KERN_PREEMPT" >> $cfgdir/cfg_proc.h
 * $test$: echo "#define CONFIG_KERN_PREEMPT 1" >> $cfgdir/cfg_proc.h
 * $test$: echo  "#undef CONFIG_KERN_HEAP" >> $cfgdir/cfg_proc.h
 * $test$: echo "#define CONFIG_KERN_HEAP 1" >> $cfgdir/cfg_proc.h
 * $test$: echo  "#undef CONFIG_KERN_HEAP_SIZE" >> $cfgdir/cfg_proc.h
 * $test$: echo "#define CONFIG_KERN_HEAP_SIZE 2097152L" >> $cfgdir/cfg_proc.h
 * $test$: cp bertos/cfg/cfg_monitor.h $cfgdir/
 * $test$: sed -i "s/CONFIG_KERN_MONITOR 0/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 <stdio.h> // sprintf
#include <string.h> // memset

#include <kern/proc.h>
#include <kern/irq.h>
#include <kern/monitor.h>

#include <drv/timer.h>
#include <cfg/test.h>
#include <cfg/cfg_proc.h>

enum
{
	TEST_OK = 1,
	TEST_FAIL = 2,
};

/* Number of tasks to spawn */
#define TASKS	8

static char name[TASKS][32];

static unsigned int done[TASKS];

static cpu_atomic_t barrier[TASKS];
static cpu_atomic_t main_barrier;

/* Base time delay for processes using timer_delay() */
#define DELAY	5

// Define process stacks for test.
#define WORKER_STACK_SIZE KERN_MINSTACKSIZE * 3

#if CONFIG_KERN_HEAP
#define WORKER_STACK(id)	 NULL
#else /* !CONFIG_KERN_HEAP */
static cpu_stack_t worker_stack[TASKS][(WORKER_STACK_SIZE +
			sizeof(cpu_stack_t) - 1) / sizeof(cpu_stack_t)];
#define WORKER_STACK(id)	 (&worker_stack[id][0])
#endif /* CONFIG_KERN_HEAP */

static int prime_numbers[] =
{
	1, 3, 5, 7, 11, 13, 17, 19,
	23, 29, 31, 37, 41, 43, 47, 53,
};
STATIC_ASSERT(TASKS <= countof(prime_numbers));

#if CONFIG_KERN_PREEMPT
/* Time to run each preemptible thread (in seconds) */
#define TIME	10

static unsigned long 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)
{
	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[%zd] running\n", __func__, pid));
		timer_delay(tot * DELAY);
	}
	done[pid - 1] = 1;
	PROC_ATOMIC(kprintf("> %s[%zd] completed\n", __func__, pid));
}

static int worker_test(void)
{
	ssize_t i;

	// Init the test processes
	cleanup();
	kputs("Run Proc test..\n");
	for (i = 0; i < TASKS; i++)
	{
		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));
	}
	/* 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)
	{
		for (i = 0; i < TASKS; i++)
		{
			if (!done[i])
				break;
		}
		if (i == TASKS)
			break;
		monitor_report();
		timer_delay(93);
	}
	kputs("> Main: process test finished..ok!\n");
	return 0;
}

#if CONFIG_KERN_PREEMPT
static void preempt_worker(void)
{
	ssize_t pid = (ssize_t)proc_currentUserData();
	unsigned long *my_count = &preempt_counter[pid - 1];
	ticks_t start, stop;
	int i;

	barrier[pid - 1] = 1;
	/* Synchronize on the main barrier */
	while (!main_barrier)
		proc_yield();
	PROC_ATOMIC(kprintf("> %s[%zd] running\n", __func__, pid));
	start = timer_clock();
	stop  = ms_to_ticks(TIME * 1000);
	while (timer_clock() - start < stop)
	{
		IRQ_ASSERT_ENABLED();
		(*my_count)++;
		/* be sure to wrap to a value different than 0 */
		if (UNLIKELY(*my_count == (unsigned int)~0))
			*my_count = 1;
	}
	PROC_ATOMIC(kprintf("> %s[%zd] completed: (counter = %lu)\n",
				__func__, pid, *my_count));
	for (i = 0; i < TASKS; i++)
		if (!preempt_counter[i])
		{
			preempt_done[pid - 1] = TEST_FAIL;
			return;
		}
	preempt_done[pid - 1] = TEST_OK;
}

static int preempt_worker_test(void)
{
	unsigned long score = 0;
	ssize_t i;

	// Init the test processes
	cleanup();
	kputs("Run Preemption test..\n");
	for (i = 0; i < TASKS; i++)
	{
		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));
	}
	kputs("> Main: Processes created\n");
	/* Synchronize on start */
	while (1)
	{
		for (i = 0; i < TASKS; i++)
			if (!barrier[i])
				break;
		if (i == TASKS)
			break;
		proc_yield();
	}
	/* Now all threads have been created, start them all */
	main_barrier = 1;
	MEMORY_BARRIER;
	kputs("> Main: Processes started\n");
	while (1)
	{
		for (i = 0; i < TASKS; i++)
		{
			if (!preempt_done[i])
				break;
			else if (preempt_done[i] == TEST_FAIL)
			{
				kputs("> Main: process test finished..fail!\n");
				return -1;
			}
		}
		if (i == TASKS)
			break;
		monitor_report();
		timer_delay(1000);
	}
	for (i = 0; i < TASKS; i++)
		score += preempt_counter[i];
	kputs("> Main: process test finished..ok!\n");
	kprintf("> Score: %lu\n", score);
	return 0;
}
#endif /* CONFIG_KERN_PREEMPT */

#if CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI

// 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_send(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),	\
					WORKER_STACK_SIZE,		\
					WORKER_STACK(num));		\
	proc_setPri(p, num + 1);					\
} while (0)

PROC_PRI_TEST(0)
PROC_PRI_TEST(1)
PROC_PRI_TEST(2)

static int prio_worker_test(void)
{
	struct Process *curr = proc_current();
	int orig_pri = curr->link.pri;
	int ret = 0;

	// test process priority
	// main process must have the higher priority to check signals received
	proc_setPri(proc_current(), 10);

	kputs("Run Priority test..\n");
	// 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))
	{
		ret = -1;
		goto out;
	}
	signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2);
	if (!(signals & SIG_USER1))
	{
		ret = -1;
		goto out;
	}
	signals = sig_wait(SIG_USER0 | SIG_USER1 | SIG_USER2);
	if (!(signals & SIG_USER0))
	{
		ret = -1;
		goto out;
	}
	// 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))
	{
		ret = -1;
		goto out;
	}
	if (signals & SIG_TIMEOUT)
	{
		kputs("Priority test successfull.\n");
	}
out:
	proc_setPri(proc_current(), orig_pri);
	if (ret != 0)
		kputs("Priority test failed.\n");
	return ret;
}
#endif /* CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI */

/**
 * Process scheduling test
 */
int proc_testRun(void)
{
	/* Start tests */
	worker_test();
#if CONFIG_KERN_PREEMPT
	preempt_worker_test();
#endif /* CONFIG_KERN_PREEMPT */
#if CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI
	prio_worker_test();
#endif /* CONFIG_KERN_SIGNALS & CONFIG_KERN_PRI */
	return 0;
}

int proc_testSetup(void)
{
	kdbg_init();

	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;
}

TEST_MAIN(proc);