Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2282 → Rev 2283

/branches/rcu/kernel/test/tasklet/tasklet1.c
28,23 → 28,98
*/
 
#include <print.h>
 
#include <arch.h>
#include <test.h>
#include <proc/tasklet.h>
#include <synch/waitq.h>
 
#include <cpu.h>
#include <proc/thread.h>
#include <arch/types.h>
#include <config.h>
 
static void func(void *data)
{
printf("%s", data);
printf("cpu%d: %s",CPU->id, data);
}
 
bool gquiet;
 
static void running_tasklet(void * data)
{
waitq_t wq;
waitq_initialize(&wq);
 
tasklet_descriptor_t *tasklet_desc;
//before we start we need to register a tasklet
if (!gquiet)
printf("Registering tasklet...");
if (!gquiet)
tasklet_desc=tasklet_register(&func, "\nTasklet called and received data from second thread\n");
else
tasklet_desc=tasklet_register(&func, "");
if (!gquiet)
printf("Done!\n");
 
//first we'll try disabling the tasklet
if (!gquiet)
printf("Disabling tasklet...");
tasklet_disable(tasklet_desc);
if (!gquiet)
printf("Done!\n");
 
//we'll schedule the disabled tasklet
if (!gquiet)
printf("Scheduling tasklet...");
tasklet_schedule(tasklet_desc);
if (!gquiet)
printf("Done!\n");
 
//and we'll wait if it gets called. It shouldn't however, because it's disabled
if (!gquiet)
printf("Waiting 1s...\n");
waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
if (!gquiet)
printf("Done!\n");
 
//then we'll try to enable it
if (!gquiet)
printf("Enabling tasklet...");
tasklet_enable(tasklet_desc);
if (!gquiet)
printf("Done!\n");
//and wait if it gets called this time. It should because it's enabled
if (!gquiet)
printf("Waiting 1s...\n");
waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
if (!gquiet)
printf("Done!\n");
 
//finally we'll free the tasklet structure
if (!gquiet)
printf("Freeing...");
tasklet_free(tasklet_desc);
if (!gquiet)
printf("Done!\n");
}
 
char * test_tasklet1(bool quiet)
{
gquiet = quiet;
waitq_t wq;
waitq_initialize(&wq);
tasklet_descriptor_t *tasklet_desc;
thread_t* second_thread;
#ifdef CONFIG_SMP
if (config.cpu_active >1) {
second_thread = thread_create(&running_tasklet, NULL, TASK, THREAD_FLAG_WIRED,"running tasklet", false);
if (CPU->id == 0)
second_thread->cpu = &cpus[1];
else
second_thread->cpu = &cpus[0];
thread_ready(second_thread);
}
#endif
 
//before we start we need to register a tasklet
if (!quiet)
70,10 → 145,10
if (!quiet)
printf("Done!\n");
 
//and we'll wait if it gets called. It shouldn't however because it's disabled
//and we'll wait if it gets called. It shouldn't however, because it's disabled
if (!quiet)
printf("Waiting 5s...");
waitq_sleep_timeout(&wq,(uint32_t) 5000000,0);
printf("Waiting 1s...\n");
waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
if (!quiet)
printf("Done!\n");
 
84,10 → 159,10
if (!quiet)
printf("Done!\n");
//and wait if it gets called this time. It should beacause it's enabled
//and wait if it gets called this time. It should because it's enabled
if (!quiet)
printf("Waiting 5s...");
waitq_sleep_timeout(&wq,(uint32_t) 5000000,0);
printf("Waiting 1s...\n");
waitq_sleep_timeout(&wq,(uint32_t) 1000000,0);
if (!quiet)
printf("Done!\n");
 
/branches/rcu/kernel/generic/include/proc/thread.h
53,7 → 53,10
 
/* Thread flags */
 
/** Thread cannot be migrated to another CPU. */
/** Thread cannot be migrated to another CPU.
* When using this flag, the caller must set cpu in the thread_t
* structure manually before calling thread_ready (even on uniprocessor)
*/
#define THREAD_FLAG_WIRED (1 << 0)
/** Thread was migrated to another CPU and has not run yet. */
#define THREAD_FLAG_STOLEN (1 << 1)
/branches/rcu/kernel/generic/src/main/main.c
275,7 → 275,7
thread_ready(t);
 
//tasklets disabled for debugging purposes
//tasklet_run_tasklet_thread(k);
tasklet_run_tasklet_thread(k);
/*
* This call to scheduler() will return to kinit,
/branches/rcu/kernel/generic/src/proc/scheduler.c
61,6 → 61,7
#include <cpu.h>
#include <print.h>
#include <debug.h>
#include <proc/tasklet.h>
 
static void before_task_runs(void);
static void before_thread_runs(void);
226,7 → 227,11
* Take the first thread from the queue.
*/
t = list_get_instance(r->rq_head.next, thread_t, rq_link);
if (verbose)
printf("cpu%d removing, rq_head %x, t: %x, next: %x, link: %x \n",CPU->id, r->rq_head, t, r->rq_head.next, t->rq_link);
list_remove(&t->rq_link);
if (verbose)
printf("cpu%d removed, rq_head %x, t: %x, next: %x, link: %x \n",CPU->id, r->rq_head, t, r->rq_head.next, t->rq_link);
 
spinlock_unlock(&r->lock);
 
438,7 → 443,8
THREAD->call_me = NULL;
THREAD->call_me_with = NULL;
}
 
if (verbose)
printf("cpu%d, Sleeping unlocking \n", CPU->id);
spinlock_unlock(&THREAD->lock);
 
break;
454,12 → 460,17
 
THREAD = NULL;
}
 
if (verbose)
printf("cpu%d looking for next thread\n", CPU->id);
THREAD = find_best_thread();
if (verbose)
printf("cpu%d t locking THREAD:%x \n", CPU->id, THREAD);
spinlock_lock(&THREAD->lock);
priority = THREAD->priority;
spinlock_unlock(&THREAD->lock);
if (verbose)
printf("cpu%d t unlocked after priority THREAD:%x \n", CPU->id, THREAD);
 
relink_rq(priority);
 
/branches/rcu/kernel/generic/src/proc/thread.c
238,6 → 238,7
cpu = CPU;
if (t->flags & THREAD_FLAG_WIRED) {
ASSERT(t->cpu != NULL);
cpu = t->cpu;
}
t->state = Ready;