Blame |
Last modification |
View Log
| RSS feed
/*
* Project: HARTIK (HA-rd R-eal TI-me K-ernel)
*
* Coordinators: Giorgio Buttazzo <giorgio@sssup.it>
* Gerardo Lamastra <gerardo@sssup.it>
*
* Authors : Paolo Gai <pj@hartik.sssup.it>
* (see authors.txt for full list of hartik's authors)
*
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
*
* http://www.sssup.it
* http://retis.sssup.it
* http://hartik.sssup.it
*/
/**
------------
CVS : $Id: testi.c,v 1.1.1.1 2002-09-02 09:37:48 pj Exp $
File: $File$
Revision: $Revision: 1.1.1.1 $
Last update: $Date: 2002-09-02 09:37:48 $
------------
Test Number 18 (I):
This test verify the correctness of the PC module.
The test uses 3 mutexes
m0 with ceiling 0
m1 with ceiling 0
m2 with ceiling 1
the main task (NRT) creates three tasks.
J0 with PC priority 0
starts at t=1.5 sec and lock m0, unlock m0, then lock and unlock m1
J1 with PC priority 1
starts at t=0.5 sec and try to lock m2
J2 with PC priority 2
it starts and locks m2
at t=1 sec it locks m1
at t=1.5 sec it unlocks m1
The example is similar to the scheduling diagram shown at p. 197 of the
book "Sistemi in tempo Reale", by Giorgio Buttazzo, Pitagora Editrice
**/
/*
* Copyright (C) 2000 Paolo Gai
*
* This program 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "kernel/kern.h"
#include "drivers/keyb.h"
mutex_t m0,m1,m2;
TIME gt(void)
{
TIME t;
kern_cli();
t = ll_gettime(TIME_EXACT,NULL);
kern_sti();
return t;
}
void startJ(void *a)
{
// task_activate((PID)a);
PID p = (PID) a;
LEVEL l;
kern_printf("startJ: %d\n",p);
l = proc_table[p].task_level;
level_table[l]->task_activate(l,p);
event_need_reschedule();
}
TASK j0()
{
kern_printf("J0: before locking m0\n");
mutex_lock(&m0);
kern_printf("J0: locked m0\n");
mutex_unlock(&m0);
kern_printf("J0: unlocked m0, locking m1\n");
mutex_lock(&m1);
kern_printf("J0: locked m1\n");
mutex_unlock(&m1);
kern_printf("J0: unlocked m1, end task\n");
return 0;
}
TASK j1()
{
kern_printf("J1: before locking m2\n");
mutex_lock(&m2);
kern_printf("J1: locked m2\n");
mutex_unlock(&m2);
kern_printf("J1: unlocked m2, end task\n");
return 0;
}
TASK j2()
{
// struct timespec t;
kern_printf("J2: before locking m2\n");
mutex_lock(&m2);
kern_printf("J2: locked m2, waiting to t=1 sec\n");
while (gt() < 1000000);
kern_printf("J2: t = 1 sec reached\n");
mutex_lock(&m1);
kern_printf("J2: locked m1, waiting to t=2 sec\n");
while (gt() < 2000000);
kern_printf("J2: t = 2 sec reached\n");
mutex_unlock(&m1);
kern_printf("J2: unlocked m1\n");
mutex_unlock(&m2);
kern_printf("J2: unlocked m2, end task\n");
return 0;
}
void fine(KEY_EVT *e)
{
sys_end();
}
int main(int argc, char **argv)
{
struct timespec t;
HARD_TASK_MODEL m;
PID p0,p1,p2;
PC_mutexattr_t a;
PI_mutexattr_t a2;
PC_RES_MODEL r;
KEY_EVT emerg;
//keyb_set_map(itaMap);
emerg.ascii = 'x';
emerg.scan = KEY_X;
emerg.flag = ALTL_BIT;
keyb_hook(emerg,fine);
/* ---------------------------------------------------------------------
Task creation
--------------------------------------------------------------------- */
hard_task_default_model(m);
hard_task_def_mit(m, 1000000);
hard_task_def_wcet(m, 20000);
PC_res_default_model(r,0);
p0 = task_create("J0", j0, &m, &r);
if (p0 == NIL)
{ kern_printf("Can't create J0 task...\n"); return 1; }
hard_task_default_model(m);
hard_task_def_mit(m, 2100000);
hard_task_def_wcet(m, 20000);
PC_res_default_model(r,1);
p1 = task_create("J1", j1, &m, &r);
if (p1 == NIL)
{ kern_printf("Can't create J1 task...\n"); return 1; }
hard_task_default_model(m);
hard_task_def_mit(m, 10000000);
hard_task_def_wcet(m, 3000000);
PC_res_default_model(r,2);
p2 = task_create("J2", j2, &m, &r);
if (p2 == NIL)
{ kern_printf("Can't create J2 task...\n"); return 1; }
/* ---------------------------------------------------------------------
Mutex creation
--------------------------------------------------------------------- */
PI_mutexattr_default(a2);
PC_mutexattr_default(a,0);
mutex_init(&m0,(mutexattr_t *)&a);
mutex_init(&m1,(mutexattr_t *)&a);
PC_mutexattr_default(a,1);
mutex_init(&m2,(mutexattr_t *)&a);
/* ---------------------------------------------------------------------
Event post
--------------------------------------------------------------------- */
t.tv_sec = 0;
t.tv_nsec = 500000000;
// t.tv_nsec = 30000000;
kern_event_post(&t,startJ,(void *)p1);
t.tv_sec = 1;
kern_event_post(&t,startJ,(void *)p0);
task_activate(p2);
kern_printf("END main\n");
return 0;
}