/demos/tags/rel_0_2/base/jointest.c |
---|
0,0 → 1,220 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, 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 |
* |
* |
* CVS : $Id: jointest.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
This test verify the correctness of the task_join primitive. (that |
function is the same as pthread_join... someday I will change the |
names...) |
There are 4 taks, J1, J2, J3, are created as joinable, J4 as detached |
The main task: |
Creates J1 and J2, locks m1 (a PI mitex), creates C3. |
at t=0.8 sec it calls a task_join on J3 (that returns EDEADLK), |
it unlocks m1, then it makes task_join on J3 another time. |
Next it creates J4 as detached and finally it does a task_join on J4 |
(that returns EINVAL). |
J1: |
at t=0.2 sec it calls task_join on J2, the it ends. |
J2: |
it simply waits t=0.4 sec and it ends. |
J3: |
First, it calls task_join on J1. |
Then, at t=0.6 sec it locks m1, then unlocks it |
J4: |
it simply waits t=1 sec and it ends. |
*/ |
#include "kernel/kern.h" |
#include "drivers/keyb.h" |
PID j0, j1, j2, j3, j4; |
mutex_t m1; |
void fine(KEY_EVT *e) |
{ |
sys_end(); |
} |
TASK J1() |
{ |
int err; |
void *ret; |
cprintf("J1: started, waiting 0.2 sec\n"); |
while (sys_gettime(NULL) < 200000); |
cprintf("J1: 0.2 sec reached, joining J2\n"); |
err = task_join(j2, &ret); |
cprintf("J1: join J2 returns %d error %d, exiting\n", |
(int)ret,err); |
return (void *)11; |
} |
TASK J2() |
{ |
cprintf("J2: started, waiting 0.4 sec\n"); |
while (sys_gettime(NULL) < 400000); |
cprintf("J2: 0.4 sec reached, exiting\n"); |
return (void *)22; |
} |
TASK J3() |
{ |
int err; |
void *ret; |
cprintf("J3: started, joining J1\n"); |
err = task_join(j1, &ret); |
cprintf("J3: join J1 returns %d error %d, waiting 0.6sec\n", (int)ret, err); |
while (sys_gettime(NULL) < 600000); |
cprintf("J1: 0.6 sec reached, locking m1\n"); |
mutex_lock(&m1); |
cprintf("J3: locked m1, unlocking m1\n"); |
mutex_unlock(&m1); |
cprintf("J3: unlocked m1, exiting\n"); |
return (void *)33; |
} |
TASK J4() |
{ |
cprintf("J4: started, waiting 1 sec\n"); |
while (sys_gettime(NULL) < 1000000); |
cprintf("J4: 1 sec reached, exiting\n"); |
return (void *)44; |
} |
int main(int argc, char **argv) |
{ |
NRT_TASK_MODEL m; |
PI_mutexattr_t a; |
KEY_EVT emerg; |
int err; |
void *ret; |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
j0 = exec_shadow; |
nrt_task_default_model(m); |
nrt_task_def_joinable(m); |
/* --------------------------------------------------------------------- |
Mutex creation |
--------------------------------------------------------------------- */ |
PI_mutexattr_default(a); |
mutex_init(&m1,&a); |
/* --------------------------------------------------------------------- |
Let's go !!!! |
--------------------------------------------------------------------- */ |
cprintf("main: creating J1,J2,J3, locking m1\n"); |
j1 = task_create("J1", J1, &m, NULL); |
if (j1 == NIL) { cprintf("Can't create J1 task...\n"); return 1; } |
task_activate(j1); |
j2 = task_create("J2", J2, &m, NULL); |
if (j2 == NIL) { cprintf("Can't create J2 task...\n"); return 1; } |
task_activate(j2); |
mutex_lock(&m1); |
j3 = task_create("J3", J3, &m, NULL); |
if (j3 == NIL) { cprintf("Can't create J3 task...\n"); return 1; } |
task_activate(j3); |
cprintf("main: waiting t=0.8 sec\n"); |
while (sys_gettime(NULL) < 800000); |
err = task_join(j3, NULL); |
cprintf("main: join J3 error %d, unlocking m1\n",err); |
mutex_unlock(&m1); |
err = task_join(j3, &ret); |
cprintf("main: join J3 returns %d error %d, unlocked m1, creating J4\n", |
(int)ret,err); |
nrt_task_def_unjoinable(m); |
j4 = task_create("J4", J4, &m, NULL); |
if (j4 == NIL) { cprintf("Can't create J4 task...\n"); return 1; } |
task_activate(j4); |
err = task_join(j4,&ret); |
cprintf("main: join J4 returns %d error %d, exiting\n", (int)ret, err); |
return 0; |
} |
/demos/tags/rel_0_2/base/mdemo.c |
---|
0,0 → 1,200 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: mdemo.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
This test verify the correctness of the NOP module. It works with the |
PI, PC, SRP module, too. |
The test uses one mutex |
the main task (NRT) creates three tasks. |
J1 with PC priority 0 |
starts at t=0.5 sec and lock m0 |
J2 with PC priority 1 |
starts at t=1 sec and doesn't lock any mutex |
J3 with PC priority 2 |
it starts and locks m0 |
at t=2 sec it unlocks m1 |
The example is similar to the scheduling diagram shown at p. 188 of the |
book "Sistemi in tempo Reale", by Giorgio Buttazzo, Pitagora Editrice |
*/ |
#include "kernel/kern.h" |
#include "drivers/keyb.h" |
#include "modules/srp.h" |
mutex_t m0; |
void startJ(void *a) |
{ |
task_activate((PID)a); |
} |
TASK j1() |
{ |
cprintf("J1: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J1: locked m0\n"); |
mutex_unlock(&m0); |
cprintf("J1: unlocked m0, end task\n"); |
return 0; |
} |
TASK j2() |
{ |
cprintf("J2: waiting t=1.5 sec\n"); |
while (sys_gettime(NULL) < 1500000); |
cprintf("J2: end task\n"); |
return 0; |
} |
TASK j3() |
{ |
cprintf("J3: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J3: locked m0, waiting to t=2 sec\n"); |
while (sys_gettime(NULL) < 2000000); |
cprintf("J3: t = 1 sec reached, unlocking m0\n"); |
mutex_unlock(&m0); |
cprintf("J3: unlocked m0, 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; |
NOP_mutexattr_t a3; |
SRP_mutexattr_t a4; |
NPP_mutexattr_t a5; |
PC_RES_MODEL r; |
SRP_RES_MODEL srp; |
KEY_EVT emerg; |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
/* --------------------------------------------------------------------- |
Mutex creation |
--------------------------------------------------------------------- */ |
PC_mutexattr_default(a,0); |
PI_mutexattr_default(a2); |
NOP_mutexattr_default(a3); |
SRP_mutexattr_default(a4); |
NPP_mutexattr_default(a5); |
mutex_init(&m0,&a4); |
/* --------------------------------------------------------------------- |
Task creation |
--------------------------------------------------------------------- */ |
hard_task_default_model(m); |
hard_task_def_wcet(m,20000); |
hard_task_def_mit(m,10000000); |
PC_res_default_model(r,0); |
SRP_res_default_model(srp,3); |
p0 = task_createn("J1", j1, (TASK_MODEL *)&m, &r, &srp, SRP_usemutex(&m0), NULL); |
if (p0 == NIL) |
{ cprintf("Can't create J1 task...\n"); return 1; } |
hard_task_def_wcet(m,1600000); |
hard_task_def_mit(m,21000000); |
PC_res_default_model(r,1); |
SRP_res_default_model(srp,2); |
p1 = task_createn("J2", j2, (TASK_MODEL *)&m, &r, &srp, NULL); |
if (p1 == NIL) |
{ cprintf("Can't create J2 task...\n"); return 1; } |
hard_task_def_wcet(m,3000000); |
hard_task_def_mit(m,100000000); |
PC_res_default_model(r,2); |
SRP_res_default_model(srp,1); |
p2 = task_createn("J3", j3, (TASK_MODEL *)&m, &r, &srp, SRP_usemutex(&m0), NULL); |
if (p2 == NIL) |
{ cprintf("Can't create J3 task...\n"); return 1; } |
/* --------------------------------------------------------------------- |
Event post |
--------------------------------------------------------------------- */ |
t.tv_sec = 0; |
t.tv_nsec = 500000000; |
kern_cli(); |
kern_event_post(&t,startJ,(void *)p0); |
t.tv_sec = 1; |
kern_event_post(&t,startJ,(void *)p1); |
kern_sti(); |
task_activate(p2); |
cprintf("END main\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/aster4.c |
---|
0,0 → 1,399 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: aster4.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
Test Number 13 (D): |
this is a part of the classic Hartik demo Aster, and it is based on aster 3. |
The demo creates: |
- a set of TBS tasks assigned to 2 TBS servers initialized with different bandwidth. |
- a set of periodic tasks, just to make noise (function asteroide) |
- a set of CBS tasks that are created to fill the available free |
bandwidth (function soft_aster) |
- a few service task (the one that creates the CBS tasks (aster), a clock, |
JET info visualization |
- a set of never ending "system tasks" that simulate a device driver |
task that will end only at shutdown (function aper_asteroid) |
- a keyboard task that will execute an hook to terminate the system |
*/ |
/* |
* 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 "modules/edf.h" |
#include "modules/cbs.h" |
#include "drivers/keyb.h" |
int num_aster = 0; |
#define ASTER_LIM 60 |
#define DISPLAY_MAX 15 |
#define ASTER_MAX 70 |
#define STAT_Y 9 |
#define PER_MAX 5 |
#define APER_MAX 8 |
// These numbers works on a Pentium 133 */ |
#define PER_WCET 25000 |
#define APER_WCET 53000 |
#define CLOCK_WCET 1000 |
#define ASTER_WCET 1000 |
#define SOFT_MET 6300 |
#define APER_REP 22000 |
PID aper_table[APER_MAX]; |
int shutting_down = 0; |
TASK asteroide(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 10000; //8000 + rand()%2000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
} |
//num_aster--; |
} |
TASK aper_asteroid(void *a) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
int c; |
char s[2]; |
c = (int)a; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = APER_REP; //8000 + rand()%2000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
s[0] = c; |
puts_xy(i,y,rand()%15+1,s); |
if (shutting_down) { |
cprintf("Ending System Task %d\n",exec_shadow); |
return 0; |
} |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
} |
} |
TASK soft_aster(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 1000 + rand()%9000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
s[0] = 1; |
puts_xy(i,y,rand()%15+1,s); |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
num_aster--; |
return 0; |
} |
TASK aster() |
{ |
PID p; |
HARD_TASK_MODEL m; |
SOFT_TASK_MODEL m_soft; |
int r; |
int x; // adaptive bandwidth... |
srand(7); |
/* create a set of periodic tasks, just to make noise */ |
hard_task_default_model(m); |
hard_task_def_wcet(m,PER_WCET); |
hard_task_def_ctrl_jet(m); |
for (x=0; x<PER_MAX; x++) { |
r = (rand() % 200); |
hard_task_def_mit(m, (64+r)*1000); |
p = task_create("per",asteroide,&m,NULL); |
if (p!=-1) task_activate(p); |
} |
soft_task_default_model(m_soft); |
soft_task_def_met(m_soft,SOFT_MET); |
soft_task_def_ctrl_jet(m_soft); |
x = 64; |
while (1) { |
if (num_aster < ASTER_MAX) { |
r = (rand() % 200); |
soft_task_def_period(m_soft, (x+r)*1000); |
p = task_create("aaa",soft_aster,&m_soft,NULL); |
if (p == -1) |
{ |
if (x < 500 && errno != ENO_AVAIL_TASK) x += 1; |
printf_xy(62,3,WHITE,"adapt=%3u err=%d", |
iq_query_first(&freedesc),errno); |
} |
else { |
num_aster++; |
printf_xy(62,3,WHITE,"adapt=%3u ",x);//,errno); |
task_activate(p); |
x /= 2; |
if (x<50) x = 50; |
} |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(0)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(4)); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(0)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(4)); |
task_endcycle(); |
} |
} |
/* we consider the first ASTER_MAX + 2 tasks from the PID 2 |
and plot on the screen the elapsed times... */ |
TASK jetcontrol() |
{ |
int i; /* a counter */ |
TIME sum, max, curr, last[5]; |
int nact; |
int j; /* the elements set by jet_gettable */ |
PID p; |
kern_cli(); |
printf_xy(0,STAT_Y,WHITE,"PID ³ Mean T.³ Max T. ³ N.A. ³ Curr. ³ Last1 ³ Last2 ³ Last3 ³ Last4 ³ Last5"); |
kern_sti(); |
for (;;) { |
for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) { |
if (jet_getstat(p, &sum, &max, &nact, &curr) == -1 || |
(proc_table[p].pclass & 0xFF00) == HARD_PCLASS) continue; |
for (j=0; j<5; j++) last[j] = 0; |
jet_gettable(p, &last[0], 5); |
kern_cli(); |
if (proc_table[p].task_level == 4) |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)CBS_get_nact(4,p), (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
else |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
kern_sti(); |
i++; |
} |
} |
} |
void endfun(KEY_EVT *k) |
{ |
sys_end(); |
} |
void exiting(void *arg) |
{ |
cprintf("System shut down...\n"); |
shutting_down = 1; |
} |
int main(int argc, char **argv) |
{ |
KEY_EVT k; |
PID p1,p2,p3; |
HARD_TASK_MODEL m; |
SOFT_TASK_MODEL m_aper; |
SOFT_TASK_MODEL m_soft; |
int i; |
k.flag = 0; |
k.scan = KEY_ENT; |
k.ascii = 13; |
keyb_hook(k, endfun); |
clear(); |
cprintf("Press ENTER to end the demo..."); |
sys_atrunlevel(exiting, NULL, RUNLEVEL_SHUTDOWN); |
hard_task_default_model(m); |
hard_task_def_wcet(m,ASTER_WCET); |
hard_task_def_mit(m,10000); |
hard_task_def_group(m,1); |
hard_task_def_ctrl_jet(m); |
soft_task_default_model(m_soft); |
soft_task_def_met(m_soft,1000); |
soft_task_def_period(m_soft,100000); |
soft_task_def_group(m_soft,1); |
soft_task_def_ctrl_jet(m_soft); |
soft_task_def_aperiodic(m_soft); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("aster4.c(main): Could not create task <aster> ..."); |
sys_end(); |
} |
hard_task_def_mit(m,500000); |
hard_task_def_wcet(m,CLOCK_WCET); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("aster4.c(main): Could not create task <Clock> ..."); |
sys_end(); |
} |
p3 = task_create("JetControl",jetcontrol,&m_soft,NULL); |
if (p3 == -1) { |
perror("aster4.c(main): Could not create task <JetControl> ..."); |
sys_end(); |
} |
soft_task_default_model(m_aper); |
soft_task_def_wcet(m_aper,APER_WCET); |
soft_task_def_ctrl_jet(m_aper); |
soft_task_def_system(m_aper); |
soft_task_def_aperiodic(m_aper); |
for (i=0; i<APER_MAX; i++) { |
soft_task_def_level(m_aper, i/4 + 2); |
soft_task_def_arg(m_aper, (void *)(i/4 ? 'Û' : '±')); |
aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL); |
if (aper_table[i] == -1) { |
perror("aster4.c(main): Could not create task <aper> ..."); |
sys_end(); |
} |
} |
group_activate(1); |
return 0; |
} |
/demos/tags/rel_0_2/base/isemdemo.c |
---|
0,0 → 1,98 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: isemdemo.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-11-11 08:22:45 $ |
------------ |
The simplest initialization file |
The tick is set to TICK ms. |
This file contains the 2 functions needed to initialize the system. |
These functions register the following levels: |
a RR (Round Robin) level |
a Dummy level |
It can accept these task models: |
NRT_TASK_MODEL at level 0 |
**/ |
/* |
* 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 "modules/rr.h" |
#include "modules/dummy.h" |
#include "modules/sem.h" |
/*+ sysyem tick in us +*/ |
#define TICK 300 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
dummy_register_level(); |
SEM_register_module(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/aster5.c |
---|
0,0 → 1,491 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Paolo Gai, Gerardo Lamastra and Giuseppe Lipari |
* |
* 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 |
* |
* |
* CVS : $Id: aster5.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
this is a part of the classic Hartik demo Aster. |
it is based on test 13 (d), and use the CBS to serve the periodic tasks. |
There are not periodic tasks, only CBS tasks. |
The tasks use a PI, NPP or NOP mutex to access the video memory. |
A flag (LONGSC) is provided to try long and short critical sections. |
This demo is really interesting because you can note the behavior of |
the system, and the differences between the various protocols... |
*/ |
#include "kernel/kern.h" |
#include "modules/edf.h" |
#include "modules/cbs.h" |
#include "drivers/keyb.h" |
int num_aster = 0; |
#define ASTER_LIM 60 |
#define DISPLAY_MAX 15 |
#define ASTER_MAX 70 |
#define STAT_Y 9 |
#define PER_MAX 5 |
#define APER_MAX 8 |
#define PER_WCET 6200 |
#define APER_WCET 18400 |
#define JET_WCET 10000 |
#define JET_PERIOD 100000 |
#define APER_REP 22000 |
//PID aper_table[APER_MAX]; |
mutex_t m1; |
#define PIMUTEX |
//#define NPPMUTEX |
//#define NOPMUTEX |
#define LONGSC |
#ifdef LONGSC |
#define SOFT_MET 3000 /* 3000 12000 */ |
#define CLOCK_WCET 400 /* 200 300*/ |
#define ASTER_WCET 400 /* 200 300*/ |
#else |
#define SOFT_MET 80000 /* 4500 */ |
#define CLOCK_WCET 2000 /* 200*/ |
#define ASTER_WCET 2000 /* 200*/ |
#endif |
TASK asteroide(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 10000; //8000 + rand()%2000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
#ifdef LONGSC |
mutex_unlock(&m1); |
#endif |
// task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
//num_aster--; |
} |
TASK aper_asteroid(void *a) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
int c; |
char s[2]; |
c = (int)a; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = APER_REP; //8000 + rand()%2000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
s[0] = c; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
mutex_unlock(&m1); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
} |
TASK soft_aster(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
/*for (;;)*/ { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 1000 + rand()%9000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
s[0] = 1; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
mutex_unlock(&m1); |
// task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
num_aster--; |
return 0; |
} |
TASK aster() |
{ |
PID p; |
// HARD_TASK_MODEL m; |
SOFT_TASK_MODEL m_soft; |
int r; |
int x; // adaptive bandwidth... |
srand(7); |
/* periodic_task_default_model(m,0,PER_WCET); |
periodic_task_def_ctrl_jet(m); |
for (x=0; x<PER_MAX; x++) { |
r = (rand() % 200); |
periodic_task_def_period(m, (64+r)*1000); |
p = task_create("per",asteroide,&m,NULL); |
if (p!=-1) task_activate(p); |
} |
*/ |
soft_task_default_model(m_soft); |
soft_task_def_met(m_soft,SOFT_MET); |
soft_task_def_ctrl_jet(m_soft); |
x = 128; //64; |
while (1) { |
/* { |
PID p; |
int x; |
p = level_table[0]->level_scheduler(0); |
printf_xy(1,8,WHITE," "); |
x = 0; |
do { |
printf_xy(3*x+1,8,WHITE,"%3d",p); |
p = proc_table[p].next; |
x++; |
} while (p != NIL); |
} |
*/ |
if (num_aster < ASTER_MAX) { |
r = (rand() % 200); |
soft_task_def_period(m_soft, (x+r)*1000); |
p = task_create("aaa",soft_aster,&m_soft,NULL); |
if (p == -1) |
{ |
if (x < 500 && errno != ENO_AVAIL_TASK) x += 1; |
mutex_lock(&m1); |
printf_xy(62,3,WHITE,"adapt=%3u err=%d", |
iq_query_first(&freedesc),errno); |
mutex_unlock(&m1); |
} |
else { |
num_aster++; |
mutex_lock(&m1); |
printf_xy(62,3,WHITE,"adapt=%3u ",x);//,errno); |
mutex_unlock(&m1); |
task_activate(p); |
x /= 2; |
if (x<50) x = 50; |
} |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
mutex_lock(&m1); |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(0)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(2)); |
mutex_unlock(&m1); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
mutex_lock(&m1); |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(0)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(2)); |
mutex_unlock(&m1); |
task_endcycle(); |
} |
} |
/* we consider the first ASTER_MAX + 2 tasks from the PID 2 |
and plot on the screen the elapsed times... */ |
TASK jetcontrol() |
{ |
int i; /* a counter */ |
TIME sum, max, curr, last[5]; |
int nact; |
int j; /* the elements set by jet_gettable */ |
PID p; |
mutex_lock(&m1); |
printf_xy(0,STAT_Y,WHITE,"PID ³ Mean T.³ Max T. ³ N.A. ³ Curr. ³ Last1 ³ Last2 ³ Last3 ³ Last4 ³ Last5"); |
mutex_unlock(&m1); |
for (;;) { |
for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) { |
if (jet_getstat(p, &sum, &max, &nact, &curr) == -1 /*|| |
(proc_table[p].pclass & 0xFF00) == APERIODIC_PCLASS || |
(proc_table[p].pclass & 0xFF00) == PERIODIC_PCLASS*/ ) continue; |
for (j=0; j<5; j++) last[j] = 0; |
jet_gettable(p, &last[0], 5); |
mutex_lock(&m1); |
if (proc_table[p].task_level == 2) |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³p%-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)CBS_get_nact(2,p), (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
// p, sum/(nact==0 ? 1 : nact), max, proc_table[p].avail_time, proc_table[p].status, proc_table[p].shadow, proc_table[p].timespec_priority.tv_sec,proc_table[p].timespec_priority.tv_nsec/1000 , CBS_get_nact(2,p), last[4]); |
else |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
// p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)proc_table[p].status, (int)proc_table[p].shadow, (int)proc_table[p].timespec_priority.tv_sec,(int)proc_table[p].timespec_priority.tv_nsec/1000 , (int)last[3], (int)last[4]); |
mutex_unlock(&m1); |
i++; |
} |
} |
} |
void fine(KEY_EVT *e) |
{ |
sys_end(); |
} |
int main(int argc, char **argv) |
{ |
PID p1,p2,p3;//,p4,p5,p6; |
HARD_TASK_MODEL m; |
// NRT_TASK_MODEL m_nrt; |
SOFT_TASK_MODEL m_aper; |
SOFT_TASK_MODEL m_soft; |
// int i; |
struct timespec fineprg; |
#ifdef PIMUTEX |
PI_mutexattr_t a; |
#endif |
#ifdef NPPMUTEX |
NPP_mutexattr_t a; |
#endif |
#ifdef NOPMUTEX |
NOP_mutexattr_t a; |
#endif |
KEY_EVT emerg; |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
clear(); |
hard_task_default_model(m); |
hard_task_def_wcet(m,ASTER_WCET); |
hard_task_def_mit(m,100000); |
hard_task_def_group(m,1); |
hard_task_def_ctrl_jet(m); |
// nrt_task_default_model(m_nrt); |
// nrt_task_def_group(m_nrt,1); |
// nrt_task_def_ctrl_jet(m_nrt); |
soft_task_default_model(m_aper); |
soft_task_def_group(m_aper,1); |
soft_task_def_ctrl_jet(m_aper); |
soft_task_def_aperiodic(m_aper); |
soft_task_default_model(m_soft); |
soft_task_def_period(m_soft,JET_PERIOD); |
soft_task_def_met(m_soft,JET_WCET); |
soft_task_def_group(m_soft,1); |
soft_task_def_ctrl_jet(m_soft); |
soft_task_def_aperiodic(m_soft); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("test7.c(main): Could not create task <aster> ..."); |
sys_end(); |
l1_exit(-1); |
} |
hard_task_def_mit(m,500000); |
hard_task_def_wcet(m,CLOCK_WCET); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <Clock> ..."); |
sys_end(); |
l1_exit(-1); |
} |
// p3 = task_create("JetControl",jetcontrol,&m_nrt,NULL); |
p3 = task_create("JetControl",jetcontrol,&m_soft,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <JetControl> ..."); |
sys_end(); |
l1_exit(-1); |
} |
/* |
aperiodic_task_default_model(m_aper,APER_WCET); |
aperiodic_task_def_ctrl_jet(m_aper); |
aperiodic_task_def_system(m_aper); |
for (i=0; i<APER_MAX; i++) { |
aperiodic_task_def_level(m_aper, i/4 + 2); |
aperiodic_task_def_arg(m_aper, (i/4 ? 'Û' : '±')); |
aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL); |
if (aper_table[i] == -1) { |
perror("test7.c(main): Could not create task <aper> ..."); |
sys_end(); |
l1_exit(-1); |
} |
} |
*/ |
task_nopreempt(); |
#ifdef PIMUTEX |
PI_mutexattr_default(a); |
#endif |
#ifdef NPPMUTEX |
NPP_mutexattr_default(a); |
#endif |
#ifdef NOPMUTEX |
NOP_mutexattr_default(a); |
#endif |
mutex_init(&m1, &a); |
fineprg.tv_sec = 1800; |
fineprg.tv_nsec = 0; |
//kern_event_post(&fineprg,(void (*)(void *))fine,NULL); |
group_activate(1); |
return 0; |
} |
/demos/tags/rel_0_2/base/aster6.c |
---|
0,0 → 1,483 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Paolo Gai, Gerardo Lamastra and Giuseppe Lipari |
* |
* 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 |
* |
* |
* CVS : $Id: aster6.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
this is a part of the classic Hartik demo Aster. |
it is based on test 17 (h), and the JobControl Task uses an |
SOFT_TASK_MODEL served by a polling server |
*/ |
#include "kernel/kern.h" |
#include "modules/edf.h" |
#include "modules/cbs.h" |
#include "drivers/keyb.h" |
int num_aster = 0; |
#define ASTER_LIM 60 |
#define DISPLAY_MAX 15 |
#define ASTER_MAX 70 |
#define STAT_Y 9 |
#define PER_MAX 5 |
#define APER_MAX 8 |
#define PER_WCET 6200 |
#define APER_WCET 18400 |
#define JET_WCET 10000 |
#define APER_REP 22000 |
PID aper_table[APER_MAX]; |
mutex_t m1; |
#define PIMUTEX |
//#define NPPMUTEX |
//#define NOPMUTEX |
#define LONGSC |
#ifdef LONGSC |
#define SOFT_MET 3000 /* 12000 */ |
#define CLOCK_WCET 200 /* 300*/ |
#define ASTER_WCET 200 /* 300*/ |
#else |
#define SOFT_MET 80000 /* 4500 */ |
#define CLOCK_WCET 2000 /* 200*/ |
#define ASTER_WCET 2000 /* 200*/ |
#endif |
TASK asteroide(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 10000; //8000 + rand()%2000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
#ifdef LONGSC |
mutex_unlock(&m1); |
#endif |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
//num_aster--; |
} |
TASK aper_asteroid(void *a) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
int c; |
char s[2]; |
c = (int)a; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = APER_REP; //8000 + rand()%2000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
s[0] = c; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
mutex_unlock(&m1); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
} |
TASK soft_aster(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
/*for (;;)*/ { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 1000 + rand()%9000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
s[0] = 1; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
mutex_unlock(&m1); |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
num_aster--; |
return 0; |
} |
TASK aster() |
{ |
PID p; |
// HARD_TASK_MODEL m; |
SOFT_TASK_MODEL m_soft; |
int r; |
int x; // adaptive bandwidth... |
srand(7); |
/* periodic_task_default_model(m,0,PER_WCET); |
periodic_task_def_ctrl_jet(m); |
for (x=0; x<PER_MAX; x++) { |
r = (rand() % 200); |
periodic_task_def_period(m, (64+r)*1000); |
p = task_create("per",asteroide,&m,NULL); |
if (p!=-1) task_activate(p); |
} |
*/ |
soft_task_default_model(m_soft); |
soft_task_def_met(m_soft,SOFT_MET); |
soft_task_def_ctrl_jet(m_soft); |
x = 128; //64; |
while (1) { |
/* { |
PID p; |
int x; |
p = level_table[0]->level_scheduler(0); |
printf_xy(1,8,WHITE," "); |
x = 0; |
do { |
printf_xy(3*x+1,8,WHITE,"%3d",p); |
p = proc_table[p].next; |
x++; |
} while (p != NIL); |
} |
*/ |
if (num_aster < ASTER_MAX) { |
r = (rand() % 200); |
soft_task_def_period(m_soft, (x+r)*1000); |
p = task_create("aaa",soft_aster,&m_soft,NULL); |
if (p == -1) |
{ |
if (x < 500 && errno != ENO_AVAIL_TASK) x += 1; |
mutex_lock(&m1); |
printf_xy(62,3,WHITE,"adapt=%3u err=%d", |
iq_query_first(&freedesc),errno); |
mutex_unlock(&m1); |
} |
else { |
num_aster++; |
mutex_lock(&m1); |
printf_xy(62,3,WHITE,"adapt=%3u ",x);//,errno); |
mutex_unlock(&m1); |
task_activate(p); |
x /= 2; |
if (x<50) x = 50; |
} |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
mutex_lock(&m1); |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(0)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(2)); |
mutex_unlock(&m1); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
mutex_lock(&m1); |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(0)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(2)); |
mutex_unlock(&m1); |
task_endcycle(); |
} |
} |
/* we consider the first ASTER_MAX + 2 tasks from the PID 2 |
and plot on the screen the elapsed times... */ |
TASK jetcontrol() |
{ |
int i; /* a counter */ |
TIME sum, max, curr, last[5]; |
int nact; |
int j; /* the elements set by jet_gettable */ |
PID p; |
mutex_lock(&m1); |
printf_xy(0,STAT_Y,WHITE,"PID ³ Mean T.³ Max T. ³ N.A. ³ Curr. ³ Last1 ³ Last2 ³ Last3 ³ Last4 ³ Last5"); |
mutex_unlock(&m1); |
for (;;) { |
for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) { |
if (jet_getstat(p, &sum, &max, &nact, &curr) == -1 /*|| |
(proc_table[p].pclass & 0xFF00) == APERIODIC_PCLASS || |
(proc_table[p].pclass & 0xFF00) == PERIODIC_PCLASS*/ ) continue; |
for (j=0; j<5; j++) last[j] = 0; |
jet_gettable(p, &last[0], 5); |
mutex_lock(&m1); |
if (proc_table[p].task_level == 2) |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)CBS_get_nact(2,p), (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
// p, sum/(nact==0 ? 1 : nact), max, proc_table[p].avail_time, proc_table[p].status, proc_table[p].shadow, proc_table[p].timespec_priority.tv_sec,proc_table[p].timespec_priority.tv_nsec/1000 , CBS_get_nact(2,p), last[4]); |
else |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, (int)nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
// p, sum/(nact==0 ? 1 : nact), max, nact, proc_table[p].status, proc_table[p].shadow, proc_table[p].timespec_priority.tv_sec,proc_table[p].timespec_priority.tv_nsec/1000 , last[3], last[4]); |
mutex_unlock(&m1); |
i++; |
} |
} |
} |
void fine(KEY_EVT *e) |
{ |
sys_end(); |
} |
int main(int argc, char **argv) |
{ |
PID p1,p2,p3; //,p4,p5,p6; |
HARD_TASK_MODEL m; |
// NRT_TASK_MODEL m_nrt; |
SOFT_TASK_MODEL m_aper; |
SOFT_TASK_MODEL m_soft; |
// int i; |
struct timespec fineprg; |
#ifdef PIMUTEX |
PI_mutexattr_t a; |
#endif |
#ifdef NPPMUTEX |
NPP_mutexattr_t a; |
#endif |
#ifdef NOPMUTEX |
NOP_mutexattr_t a; |
#endif |
KEY_EVT emerg; |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
set_exchandler_grx(); |
clear(); |
hard_task_default_model(m); |
hard_task_def_mit(m,100000); |
hard_task_def_wcet(m,ASTER_WCET); |
hard_task_def_group(m,1); |
hard_task_def_ctrl_jet(m); |
// nrt_task_default_model(m_nrt); |
// nrt_task_def_group(m_nrt,1); |
// nrt_task_def_ctrl_jet(m_nrt); |
soft_task_default_model(m_aper); |
soft_task_def_group(m_aper,1); |
soft_task_def_ctrl_jet(m_aper); |
soft_task_def_aperiodic(m_aper); |
soft_task_default_model(m_soft); |
soft_task_def_period(m_soft,100000); |
soft_task_def_met(m_soft,JET_WCET); |
soft_task_def_group(m_soft,1); |
soft_task_def_ctrl_jet(m_soft); |
soft_task_def_aperiodic(m_soft); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("test7.c(main): Could not create task <aster> ..."); |
sys_end(); |
l1_exit(-1); |
} |
hard_task_def_mit(m,500000); |
hard_task_def_wcet(m,CLOCK_WCET); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <Clock> ..."); |
sys_end(); |
l1_exit(-1); |
} |
// p3 = task_create("JetControl",jetcontrol,&m_nrt,NULL); |
p3 = task_create("JetControl",jetcontrol,&m_aper,NULL); |
if (p3 == -1) { |
perror("test7.c(main): Could not create task <JetControl> ..."); |
sys_end(); |
l1_exit(-1); |
} |
/* |
aperiodic_task_default_model(m_aper,APER_WCET); |
aperiodic_task_def_ctrl_jet(m_aper); |
aperiodic_task_def_system(m_aper); |
for (i=0; i<APER_MAX; i++) { |
aperiodic_task_def_level(m_aper, i/4 + 2); |
aperiodic_task_def_arg(m_aper, (i/4 ? 'Û' : '±')); |
aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL); |
if (aper_table[i] == -1) { |
perror("test7.c(main): Could not create task <aper> ..."); |
sys_end(); |
l1_exit(-1); |
} |
} |
*/ |
task_nopreempt(); |
#ifdef PIMUTEX |
PI_mutexattr_default(a); |
#endif |
#ifdef NPPMUTEX |
NPP_mutexattr_default(a); |
#endif |
#ifdef NOPMUTEX |
NOP_mutexattr_default(a); |
#endif |
mutex_init(&m1, &a); |
fineprg.tv_sec = 1800; |
fineprg.tv_nsec = 0; |
kern_event_post(&fineprg,(void (*)(void *))fine,NULL); |
group_activate(1); |
return 0; |
} |
/demos/tags/rel_0_2/base/aster7.c |
---|
0,0 → 1,309 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, Paolo Gai, Massimiliano Giorgi |
* |
* 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 |
* |
* |
* CVS : $Id: aster7.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
this is a part of the classic Hartik demo Aster. |
it is based on test 10(A), and test the PS with RM. |
The JetControl is served by a dedicated Polling Server, too. |
There are APER_MAX tasks sleeping, and when an asteroide task finish |
the current activation, it activate also an aperiodic task chosen |
randomly (if the task chosen is already active, the task_activate do |
nothing!) |
*/ |
#include "kernel/kern.h" |
#include "modules//edf.h" |
#include "drivers/keyb.h" |
int num_aster = 0; |
#define ASTER_LIM 60 |
#define DISPLAY_MAX 15 |
#define ASTER_MAX 70 |
#define STAT_Y 9 |
#define APER_MAX 8 |
/* Pentium 133 / Celeron 366 */ |
#define PER_WCET 25000 /* 7800 */ |
#define APER_WCET 5500 /* 1400 */ |
#define CLOCK_WCET 500 /* 200 */ |
#define ASTER_WCET 500 /* 200 */ |
#define APER_REP 2200 |
PID aper_table[APER_MAX]; |
TASK asteroide(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
/*for (;;)*/ { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 10000; //8000 + rand()%2000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
} |
num_aster--; |
return 0; |
} |
TASK aper_asteroid(void *a) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
int c; |
char s[2]; |
c = (int)a; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = APER_REP; //8000 + rand()%2000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
s[0] = c; |
puts_xy(i,y,rand()%15+1,s); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
} |
} |
TASK aster() |
{ |
PID p; |
HARD_TASK_MODEL m; |
int r; |
int x; // adaptive bandwidth... |
hard_task_default_model(m); |
hard_task_def_wcet(m,PER_WCET); |
hard_task_def_ctrl_jet(m); |
x = 200; |
srand(7); |
while (1) { |
if (num_aster < ASTER_MAX) { |
r = (rand() % 200); |
hard_task_def_arg(m,(void *)((rand() % 7)+1)); |
hard_task_def_mit(m, (x+r)*1000); |
p = task_create("aaa",asteroide,&m,NULL); |
if (p == -1) |
{ |
if (x < 500 && errno != ENO_AVAIL_TASK) x += 1; |
printf_xy(62,3,WHITE,"adapt=%3u err=%d", |
iq_query_first(&freedesc),errno); |
} |
else { |
num_aster++; |
printf_xy(62,3,WHITE,"adapt=%3u ",x);//,errno); |
task_activate(p); |
x /= 2; |
if (x<50) x = 50; |
} |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0)); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0)); |
task_endcycle(); |
} |
} |
/* we consider the first ASTER_MAX + 2 tasks from the PID 2 |
and plot on the screen the elapsed times... */ |
TASK jetcontrol() |
{ |
int i; /* a counter */ |
TIME sum, max, curr, last[5]; |
int nact; |
int j; /* the elements set by jet_gettable */ |
PID p; |
kern_cli(); |
printf_xy(0,STAT_Y,WHITE,"PID ³ Mean T.³ Max T. ³ N.A. ³ Curr. ³ Last1 ³ Last2 ³ Last3 ³ Last4 ³ Last5"); |
kern_sti(); |
for (;;) { |
for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) { |
if (jet_getstat(p, &sum, &max, &nact, &curr) == -1) continue; |
for (j=0; j<5; j++) last[j] = 0; |
jet_gettable(p, &last[0], 5); |
kern_cli(); |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
kern_sti(); |
i++; |
} |
} |
} |
void fine(KEY_EVT *e) |
{ |
sys_end(); |
} |
int main(int argc, char **argv) |
{ |
PID p1,p2,p3; //,p4,p5,p6; |
HARD_TASK_MODEL m; |
NRT_TASK_MODEL m_nrt; |
SOFT_TASK_MODEL m_aper; |
int i; |
KEY_EVT emerg; |
clear(); |
cprintf("Press Alt-x to end the demo..."); |
set_exchandler_grx(); |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
hard_task_default_model(m); |
hard_task_def_wcet(m,ASTER_WCET); |
hard_task_def_mit(m,10000); |
hard_task_def_group(m,1); |
hard_task_def_ctrl_jet(m); |
nrt_task_default_model(m_nrt); |
nrt_task_def_group(m_nrt,1); |
nrt_task_def_ctrl_jet(m_nrt); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("test7.c(main): Could not create task <aster> ..."); |
sys_end(); |
} |
hard_task_def_mit(m,500000); |
hard_task_def_wcet(m,CLOCK_WCET); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <Clock> ..."); |
sys_end(); |
} |
soft_task_default_model(m_aper); |
soft_task_def_ctrl_jet(m_aper); |
soft_task_def_level(m_aper, 1); |
soft_task_def_group(m_aper,1); |
soft_task_def_aperiodic(m_aper); |
p3 = task_create("JetControl",jetcontrol,&m_aper,NULL); |
if (p3 == -1) { |
perror("test7.c(main): Could not create task <JetControl> ..."); |
sys_end(); |
} |
soft_task_def_wcet(m_aper,APER_WCET); |
soft_task_def_ctrl_jet(m_aper); |
soft_task_def_aperiodic(m_aper); |
for (i=0; i<APER_MAX; i++) { |
soft_task_def_level(m_aper, i/4 + 3); |
soft_task_def_arg(m_aper, (void *)(i/4 ? 'Û' : '±')); |
aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL); |
if (aper_table[i] == -1) { |
perror("test7.c(main): Could not create task <aper> ..."); |
sys_end(); |
} |
} |
group_activate(1); |
return 0; |
} |
/demos/tags/rel_0_2/base/aster8.c |
---|
0,0 → 1,544 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, Paolo Gai, Massimiliano Giorgi |
* |
* 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 |
* |
* |
* CVS : $Id: aster8.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
Test for Sporadic Server (ss): |
this is a part of the classic Hartik demo Aster. |
it is based on test 17 (h), and the JobControl Task uses an |
SOFT_TASK_MODEL served by a sporadic server |
There are two "dummy" tasks that increment a counter and print |
the value. One uses a SOFT_TASK_MODEL served by sporadic server, |
the other uses a NRT_TASK_MODEL handled by RR module. |
*/ |
#include "kernel/kern.h" |
#include "modules/edf.h" |
#include "modules/cbs.h" |
#include "modules/ss.h" |
#include "drivers/keyb.h" |
int num_aster = 0; |
#define EDF_LEV 0 |
#define CBS_LEV 1 |
#define SS_LEV 2 |
#define ASTER_LIM 60 |
#define DISPLAY_MAX 8 |
#define ASTER_MAX 70 |
#define STAT_Y 9 |
#define PER_MAX 5 |
#define APER_MAX 8 |
#define PER_WCET 16000 |
#define APER_WCET 22000 |
#define JET_WCET 20000 |
#define APER_REP 22000 |
PID aper_table[APER_MAX]; |
mutex_t m1; |
#define PIMUTEX |
//#define PCMUTEX |
//#define NPPMUTEX |
//#define NOPMUTEX |
#define LONGSC |
#ifdef LONGSC |
#define SOFT_MET 12000 /* 12000 */ |
#define CLOCK_WCET 300 /* 300*/ |
#define ASTER_WCET 300 /* 300*/ |
#else |
#define SOFT_MET 5000 /* 4500 */ |
#define CLOCK_WCET 2000 /* 200*/ |
#define ASTER_WCET 2000 /* 200*/ |
#endif |
PID p1,p2,p3,p4,p5; |
TASK asteroide(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 10000; //8000 + rand()%2000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
#ifdef LONGSC |
mutex_unlock(&m1); |
#endif |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
//num_aster--; |
} |
TASK aper_asteroid(void *a) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
int c; |
char s[2]; |
c = (int)a; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = APER_REP; //8000 + rand()%2000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
s[0] = c; |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
mutex_lock(&m1); |
puts_xy(i,y,rand()%15+1,s); |
mutex_unlock(&m1); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
} |
TASK soft_aster(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
/*for (;;)*/ { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 1000 + rand()%9000; |
#ifdef LONGSC |
mutex_lock(&m1); |
#endif |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
puts_xy(i,y,rand()%15+1,s); |
#ifndef LONGSC |
mutex_unlock(&m1); |
#endif |
} |
s[0] = 1; |
#ifndef LONGSC |
mutex_lock(&m1); |
#endif |
//mutex_lock(&m1); |
puts_xy(i,y,rand()%15+1,s); |
mutex_unlock(&m1); |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
mutex_lock(&m1); |
puts_xy(i,y,WHITE," "); |
mutex_unlock(&m1); |
i++; |
} |
} |
num_aster--; |
return 0; |
} |
TASK aster() |
{ |
PID p; |
// HARD_TASK_MODEL m; |
SOFT_TASK_MODEL m_soft; |
int r; |
int x; // adaptive bandwidth... |
srand(7); |
/* periodic_task_default_model(m,0,PER_WCET); |
periodic_task_def_ctrl_jet(m); |
for (x=0; x<PER_MAX; x++) { |
r = (rand() % 200); |
periodic_task_def_period(m, (64+r)*1000); |
p = task_create("per",asteroide,&m,NULL); |
if (p!=-1) task_activate(p); |
} |
*/ |
soft_task_default_model(m_soft); |
soft_task_def_met(m_soft,SOFT_MET); |
soft_task_def_ctrl_jet(m_soft); |
// soft_task_def_aperiodic(m_soft); |
x = 128; //64; |
while (1) { |
/* { |
PID p; |
int x; |
p = level_table[0]->level_scheduler(0); |
printf_xy(1,8,WHITE," "); |
x = 0; |
do { |
printf_xy(3*x+1,8,WHITE,"%3d",p); |
p = proc_table[p].next; |
x++; |
} while (p != NIL); |
} |
*/ |
if (num_aster < ASTER_MAX) { |
r = (rand() % 200); |
soft_task_def_period(m_soft, (x+r)*1000); |
p = task_create("aaa",soft_aster,&m_soft,NULL); |
if (p == -1) |
{ |
if (x < 500 && errno != ENO_AVAIL_TASK) x += 1; |
mutex_lock(&m1); |
printf_xy(62,3,WHITE,"adapt=%3u err=%d", |
iq_query_first(&freedesc), errno); |
mutex_unlock(&m1); |
} |
else { |
num_aster++; |
mutex_lock(&m1); |
printf_xy(62,3,WHITE,"adapt=%3u ",x); |
mutex_unlock(&m1); |
task_activate(p); |
x /= 2; |
if (x<50) x = 50; |
} |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
mutex_lock(&m1); |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(EDF_LEV)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(CBS_LEV)); |
printf_xy(62,5,WHITE,"CSss=%6d",SS_availCs(SS_LEV)); |
mutex_unlock(&m1); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
mutex_lock(&m1); |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"Uedf=%12u",EDF_usedbandwidth(EDF_LEV)); |
printf_xy(62,4,WHITE,"Ucbs=%12u",CBS_usedbandwidth(CBS_LEV)); |
printf_xy(62,5,WHITE,"CSss=%6d",SS_availCs(SS_LEV)); |
mutex_unlock(&m1); |
task_endcycle(); |
} |
} |
/* we consider the first ASTER_MAX + 2 tasks from the PID 2 |
and plot on the screen the elapsed times... */ |
TASK jetcontrol() |
{ |
int i; /* a counter */ |
TIME sum, max, curr, last[5]; |
int nact; |
int j; /* the elements set by jet_gettable */ |
PID p; |
mutex_lock(&m1); |
printf_xy(0,STAT_Y,WHITE,"PID ³ Mean T.³ Max T. ³ N.A. ³ Curr. ³ Last1 ³ Last2 ³ Last3 ³ Last4 ³ Last5"); |
mutex_unlock(&m1); |
for (;;) { |
for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) { |
if (jet_getstat(p, &sum, &max, &nact, &curr) == -1 /*|| |
(proc_table[p].pclass & 0xFF00) == APERIODIC_PCLASS || |
(proc_table[p].pclass & 0xFF00) == PERIODIC_PCLASS*/ ) continue; |
for (j=0; j<5; j++) last[j] = 0; |
jet_gettable(p, &last[0], 5); |
mutex_lock(&m1); |
if (proc_table[p].task_level == 1) |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)CBS_get_nact(2,p), (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
// p, sum/(nact==0 ? 1 : nact), max, proc_table[p].avail_time, proc_table[p].status, proc_table[p].shadow, proc_table[p].timespec_priority.tv_sec,proc_table[p].timespec_priority.tv_nsec/1000 , CBS_get_nact(2,p), last[4]); |
else |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, (int)nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
// p, sum/(nact==0 ? 1 : nact), max, nact, proc_table[p].status, proc_table[p].shadow, proc_table[p].timespec_priority.tv_sec,proc_table[p].timespec_priority.tv_nsec/1000 , last[3], last[4]); |
mutex_unlock(&m1); |
i++; |
task_activate(p3); |
task_endcycle(); |
} |
} |
} |
void fine(KEY_EVT *e) |
{ |
sys_end(); |
} |
void mydummyaper(void) { |
int i=0; |
while(1) { |
mutex_lock(&m1); |
printf_xy(1,24,RED,"dummyAPER pid=%d: %d",p4,i++); |
mutex_unlock(&m1); |
task_activate(p4); |
task_endcycle(); |
} |
} |
void mydummynrt(void) { |
int i=0; |
while(1) { |
mutex_lock(&m1); |
printf_xy(40,24,RED,"dummyNRT pid=%d: %d",p5,i++); |
mutex_unlock(&m1); |
} |
} |
int main(int argc, char **argv) |
{ |
// PID p1,p2,p5; |
HARD_TASK_MODEL m; |
NRT_TASK_MODEL m_nrt; |
SOFT_TASK_MODEL m_aper; |
SOFT_TASK_MODEL m_soft; |
#ifdef PIMUTEX |
PI_mutexattr_t a; |
#endif |
#ifdef PCMUTEX |
PC_mutexattr_t a; |
#endif |
#ifdef NPPMUTEX |
NPP_mutexattr_t a; |
#endif |
#ifdef NOPMUTEX |
NOP_mutexattr_t a; |
#endif |
KEY_EVT emerg; |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
clear(); |
cprintf("Press Alt-x to end the demo..."); |
set_exchandler_grx(); |
hard_task_default_model(m); |
hard_task_def_mit(m,100000); |
hard_task_def_wcet(m,ASTER_WCET); |
hard_task_def_group(m,1); |
hard_task_def_ctrl_jet(m); |
nrt_task_default_model(m_nrt); |
nrt_task_def_group(m_nrt,1); |
nrt_task_def_ctrl_jet(m_nrt); |
soft_task_default_model(m_aper); |
soft_task_def_group(m_aper,1); |
soft_task_def_ctrl_jet(m_aper); |
soft_task_def_aperiodic(m_aper); |
soft_task_default_model(m_soft); |
soft_task_def_period(m_soft,10000); |
soft_task_def_met(m_soft,JET_WCET); |
soft_task_def_group(m_soft,1); |
soft_task_def_ctrl_jet(m_soft); |
soft_task_def_aperiodic(m_soft); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("test7.c(main): Could not create task <aster> ..."); |
sys_end(); |
l1_exit(-1); |
} |
hard_task_def_mit(m,50000); |
hard_task_def_wcet(m,CLOCK_WCET); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <Clock> ..."); |
sys_end(); |
l1_exit(-1); |
} |
// p3 = task_create("JetControl",jetcontrol,&m_nrt,NULL); |
p3 = task_create("JetControl",jetcontrol,&m_aper,NULL); |
if (p3 == -1) { |
perror("test7.c(main): Could not create task <JetControl> ..."); |
sys_end(); |
l1_exit(-1); |
} |
p4 = task_create("MyDummyAper",(void *(*)(void*))mydummyaper,&m_aper,NULL); |
if (p4 == -1) { |
perror("Could not create task <MyDummyAper> ..."); |
sys_end(); |
l1_exit(-1); |
} |
p5 = task_create("MyDummyNRT",(void *(*)(void*))mydummynrt,&m_nrt,NULL); |
if (p5 == -1) { |
perror("Could not create task <MyDummyNRT> ..."); |
sys_end(); |
l1_exit(-1); |
} |
/* |
aperiodic_task_default_model(m_aper,APER_WCET); |
aperiodic_task_def_ctrl_jet(m_aper); |
aperiodic_task_def_system(m_aper); |
for (i=0; i<APER_MAX; i++) { |
aperiodic_task_def_level(m_aper, i/4 + 2); |
aperiodic_task_def_arg(m_aper, (i/4 ? 'Û' : '±')); |
aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL); |
if (aper_table[i] == -1) { |
perror("test7.c(main): Could not create task <aper> ..."); |
sys_end(); |
l1_exit(-1); |
} |
} |
*/ |
// task_nopreempt(); |
#ifdef PIMUTEX |
PI_mutexattr_default(a); |
#endif |
#ifdef PCMUTEX |
PC_mutexattr_default(a); |
#endif |
#ifdef NPPMUTEX |
NPP_mutexattr_default(a); |
#endif |
#ifdef NOPMUTEX |
NOP_mutexattr_default(a); |
#endif |
mutex_init(&m1, &a); |
group_activate(1); |
return 0; |
} |
/demos/tags/rel_0_2/base/imdemo.c |
---|
0,0 → 1,99 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: imdemo.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
**/ |
#include "kernel/kern.h" |
#include "modules/edf.h" |
#include "modules/cbs.h" |
#include "modules/rr.h" |
#include "modules/dummy.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "modules/pi.h" |
#include "modules/pc.h" |
#include "modules/srp.h" |
#include "modules/npp.h" |
#include "modules/nop.h" |
#include "drivers/keyb.h" |
/*+ sysyem tick in us +*/ |
//#define TICK 1000 |
#define TICK 0 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
CBS_register_level(CBS_ENABLE_ALL, 0); |
dummy_register_level(); |
SEM_register_module(); |
CABS_register_module(); |
PI_register_module(); |
PC_register_module(); |
NPP_register_module(); |
SRP_register_module(); |
NOP_register_module(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
HARTPORT_init(); |
KEYB_init(NULL); |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/memtest.c |
---|
0,0 → 1,101 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, 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 |
* |
* |
* CVS : $Id: memtest.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
*/ |
/* |
* 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 <stdlib.h> |
int main(int argc, char **argv) |
{ |
void *a; |
clear(); |
a = malloc(4500); |
cprintf("malloc : %ld\n", (DWORD)a); |
free(a); |
kern_cli(); a = DOS_alloc(4500); kern_sti(); |
cprintf("below 1 M: %ld\n", (DWORD)a); |
kern_cli(); DOS_free(a,4500); kern_sti(); |
kern_cli(); a = kern_alloc_aligned(10000,MEMORY_UNDER_16M,10,0); kern_sti(); |
cprintf("below 16M: %ld\n", (DWORD)a); |
kern_cli(); kern_free(a,10000); kern_sti(); |
kern_cli(); a = kern_alloc_aligned(10000,MEMORY_FROM_1M_TO_16M,2,0); kern_sti(); |
cprintf(">1M <16M : %ld\n", (DWORD)a); |
kern_cli(); kern_free(a,10000); kern_sti(); |
kern_cli(); a = kern_alloc(10000); kern_sti(); |
cprintf("normal : %ld\n", (DWORD)a); |
kern_cli(); kern_free(a,10000); kern_sti(); |
kern_cli(); a = kern_alloc_page(MEMORY_UNDER_1M); kern_sti(); |
cprintf("page <1M : %ld\n", (DWORD)a); |
kern_cli(); kern_free_page(a); kern_sti(); |
kern_cli(); a = kern_alloc_page(MEMORY_FROM_1M_TO_16M); kern_sti(); |
cprintf("p>1<16M : %ld\n", (DWORD)a); |
kern_cli(); kern_free_page(a); kern_sti(); |
kern_cli(); a = kern_alloc_page(0); kern_sti(); |
cprintf("page : %ld\n", (DWORD)a); |
kern_cli(); kern_free_page(a); kern_sti(); |
return 0; |
} |
/demos/tags/rel_0_2/base/sched.c |
---|
0,0 → 1,477 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, Paolo Gai, Massimiliano Giorgi |
* |
* 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 |
* |
* |
* CVS : $Id: sched.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
This demo is derived from the cbsmouse.c Hartik's example. |
It only prints the task scheduling in graphic mode... |
There is a parameter to choose the type of scheduling module |
to initialize. |
to init correctly the module and task bandwidth parameters, set the defines |
NUM and DEN in initg.c and testg.c and remember the "s" (soft) parameter!!! |
to plot the deadlines assigned by CBS or TBS, compile cbs.c or tbs.c with |
the TESTG define |
(gray dots over the mouse line are the deadlines, green dots are CBS |
shifts) |
Note that a lot of times the demo exits with an exception; to avoid |
these exception you have to properly tune the task parameters. |
On a well configured machine, you will notice the little differences |
between different servers when moving the mouse ;-) |
*/ |
#include <kernel/kern.h> |
#include <drivers/glib.h> |
#include <drivers/keyb.h> |
#include <drivers/mouse.h> |
#include <semaphore.h> |
/*--------------------------------------------------------------*/ |
/* TEST ON EDF SCHEDULING */ |
/*--------------------------------------------------------------*/ |
#define LMOUSE 20 |
#define LM 40 /* line of main */ |
#define OFFSET 20 /* initial phase */ |
#define CHAR_DIM 8 /* Height of chars in pixels */ |
#define DX (640/5-1) |
int col[3] = {2, 4, 14}; /* colors of timelines */ |
int lev[3] = {80, 120, 160}; /* level of timelines */ |
int ptime[3] = {10, 20, 25}; /* number of cycles */ |
int period[3] = {40, 50,100}; /* tasks' periods */ |
int tick = 1; /* system tick */ |
int tscale = 1; /* time scale */ |
TIME starttime = 0; /* Simulation start time (scaled) */ |
char *title; /* used in initg.c */ |
/* period[] is scaled with a factor of PERIODSCALE usec */ |
#define PERIODSCALE 5000 |
// update also isched.c!!! |
#define NUM 2000 |
#define DEN 64000 |
sem_t mutex; /* Semaphore for graphix*/ |
//#define IY(y) (480 - y) |
#define IY(y) y |
/* |
* mouse cursor |
* |
*/ |
#define W WHITE |
#define R RED |
#define G GREEN |
#define M MAGENTA |
/* shape */ |
BYTE mycursor[16*16]= { |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
0,W,W,W,W,0,0,0,0,0,0,W,W,W,W,0, |
0,W,M,0,0,0,0,0,0,0,0,0,0,M,W,0, |
0,W,0,M,0,0,0,0,0,0,0,0,M,0,W,0, |
0,W,0,0,M,0,0,0,0,0,0,M,0,0,W,0, |
0,0,0,0,0,M,0,0,0,0,M,0,0,0,0,0, |
0,0,0,0,0,0,G,G,G,G,0,0,0,0,0,0, |
0,0,0,0,0,0,G,0,0,G,0,0,0,0,0,0, |
0,0,0,0,0,0,G,0,0,G,0,0,0,0,0,0, |
0,0,0,0,0,0,G,0,0,G,0,0,0,0,0,0, |
0,0,0,0,0,0,G,G,G,G,0,0,0,0,0,0, |
0,0,0,0,0,0,M,M,M,M,0,0,0,0,0,0, |
0,0,0,0,0,0,M,M,M,M,0,0,0,0,0,0, |
0,0,0,0,0,M,M,M,M,M,M,0,0,0,0,0, |
0,0,0,0,M,M,M,M,M,M,M,M,0,0,0,0, |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
}; |
#define F 0xff |
#define B 0x00 |
/* mask */ |
BYTE mybkg[16*16]= { |
B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B, |
B,0,0,0,0,B,F,F,F,F,B,0,0,0,0,B, |
B,0,0,B,B,F,F,F,F,F,B,B,B,0,0,B, |
B,0,B,0,B,F,F,F,F,F,F,B,0,B,0,B, |
B,0,B,B,0,B,F,F,F,F,B,0,B,B,0,B, |
B,B,B,F,B,0,B,B,B,B,0,B,F,B,B,B, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,B,0,0,0,0,0,0,B,F,F,F,F, |
F,F,F,B,0,0,0,0,0,0,0,0,B,F,F,F, |
F,F,F,B,B,B,B,B,B,B,B,B,B,F,F,F, |
}; |
#undef B |
#define B 0xff |
/* bad mask */ |
BYTE mybadbkg[16*16]= { |
B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B, |
B,0,0,0,0,B,F,F,F,F,B,0,0,0,0,B, |
B,0,0,B,B,F,F,F,F,F,B,B,B,0,0,B, |
B,0,B,0,B,F,F,F,F,F,F,B,0,B,0,B, |
B,0,B,B,0,B,F,F,F,F,B,0,B,B,0,B, |
B,B,B,F,B,0,B,B,B,B,0,B,F,B,B,B, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,B,B,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,F,B,0,0,0,0,B,F,F,F,F,F, |
F,F,F,F,B,0,0,0,0,0,0,B,F,F,F,F, |
F,F,F,B,0,0,0,0,0,0,0,0,B,F,F,F, |
F,F,F,B,B,B,B,B,B,B,B,B,B,F,F,F, |
}; |
/* very bad mask */ |
BYTE myverybadbkg[16*16]= { |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
F,F,F,F,F,F,F,F,F,F,F,F,F,F,F,F, |
}; |
/*--------------------------------------------------------------*/ |
/* Prints a grid to show task periods during execution */ |
/*--------------------------------------------------------------*/ |
void print_grid() |
{ |
int i; |
int a1, a2, a3; |
int temp; |
a1 = 0; |
a2 = 0; |
a3 = 0; |
temp = 0; |
grx_text(title, 0, 240-10 ,10, 0); |
grx_line(OFFSET, lev[0], 639, lev[0], 5); |
grx_line(OFFSET, lev[1], 639, lev[1], 5); |
grx_line(OFFSET, lev[2], 639, lev[2], 5); |
grx_text("T1", 0, lev[0]-8, 9, 0); |
grx_text("T2", 0, lev[1]-8, 9, 0); |
grx_text("T3", 0, lev[2]-8, 9, 0); |
grx_text("MA", 0, LM, 8, 0); |
grx_text("MO", 0, LMOUSE, 8, 0); |
for (i = OFFSET; i < 640; i++) { |
if (temp >= a1) { |
grx_line(i, lev[0] - 1, i, lev[0] - 20, 3); |
a1 += period[0]; |
} |
if (temp >= a2) { |
grx_line(i, lev[1] - 1, i, lev[1] - 20, 3); |
a2 += period[1]; |
} |
if (temp >= a3) { |
grx_line(i, lev[2] - 1, i, lev[2] - 20, 3); |
a3 += period[2]; |
} |
temp += tick/tscale; |
} |
} |
/*--------------------------------------------------------------*/ |
/* This function is called at system termination */ |
/*--------------------------------------------------------------*/ |
void my_end() |
{ |
grx_close(); |
} |
/*--------------------------------------------------------------*/ |
/* GENERIC PERIODIC PROCESS */ |
/*--------------------------------------------------------------*/ |
TASK color(int k) |
{ |
int i; |
DWORD x = OFFSET; |
TIME t; |
while ( x < 640L) { |
for (i = 0; i < ptime[k]; i++) { |
t = sys_gettime(NULL) / PERIODSCALE; |
x = (t - starttime) + OFFSET; |
if (x>=640) break; |
sem_wait(&mutex); |
grx_plot(x, lev[k] - 4, col[k]); |
grx_plot(x, lev[k] - 5, col[k]); |
grx_plot(x, lev[k] - 6, col[k]); |
grx_plot(x, lev[k] - 7, col[k]); |
sem_post(&mutex); |
while (sys_gettime(NULL)/PERIODSCALE == t); |
} |
task_endcycle(); |
} |
return 0; |
} |
void my_mouse_handler(MOUSE_EVT *ev) |
{ |
int x; |
x = (sys_gettime(NULL)/PERIODSCALE - starttime) + OFFSET; |
if (x>=640) return; |
sem_wait(&mutex); |
grx_plot(x, LMOUSE, 8); |
sem_post(&mutex); |
} |
/*--------------------------------------------------------------*/ |
/* MAIN PROCESS */ |
/*--------------------------------------------------------------*/ |
int main(int argc, char *argv[]) |
{ |
int x = OFFSET; |
MOUSE_PARMS mouse = BASE_MOUSE; |
HARD_TASK_MODEL mouse_hard; |
SOFT_TASK_MODEL mouse_soft; |
NRT_TASK_MODEL mouse_nrt; |
char c; |
KEY_EVT emerg; |
HARD_TASK_MODEL m_per; |
int modenum; |
set_exchandler_grx(); |
if (argc>=3) |
switch(*argv[2]) { |
case 'h': |
/* this is not correct, because it don't remember activations */ |
hard_task_default_model(mouse_hard); |
hard_task_def_mit(mouse_hard,DEN); |
hard_task_def_wcet(mouse_hard,NUM); |
hard_task_def_system(mouse_hard); |
hard_task_def_nokill(mouse_hard); |
hard_task_def_aperiodic(mouse_hard); |
mouse_def_task(mouse,(TASK_MODEL *)&mouse_hard); |
break; |
case 's': |
soft_task_default_model(mouse_soft); |
soft_task_def_wcet(mouse_soft,NUM); |
soft_task_def_met(mouse_soft,NUM); |
soft_task_def_period(mouse_soft,DEN); |
soft_task_def_system(mouse_soft); |
soft_task_def_nokill(mouse_soft); |
soft_task_def_aperiodic(mouse_soft); |
mouse_def_task(mouse,(TASK_MODEL *)&mouse_soft); |
break; |
case 'n': |
/* this is not correct, because it don't remember activations */ |
nrt_task_default_model(mouse_nrt); |
nrt_task_def_system(mouse_nrt); |
nrt_task_def_nokill(mouse_nrt); |
mouse_def_task(mouse,(TASK_MODEL *)&mouse_nrt); |
break; |
default: |
argc=0; |
break; |
} |
/* Serial mous on COM3 */ |
mouse_def_ms(mouse,2); |
if (argc>=4) { |
period[0]=atoi(argv[3]); |
if (period[0]<ptime[0]) period[0]=ptime[0]+5; |
} |
if (argc>=5) { |
period[1]=atoi(argv[4]); |
if (period[1]<ptime[1]) period[1]=ptime[1]+5; |
} |
if (argc>=6) { |
period[2]=atoi(argv[5]); |
if (period[2]<ptime[2]) period[2]=ptime[2]+5; |
} |
if (argc<2) { |
cprintf("syntax: x testg <config> <mouse-task> [t1] [t2] [t3]\n"); |
cprintf("where <config> can be:\n"); |
cprintf("\t0 - EDF + CBS + RR\n"); |
cprintf("\t1 - RM + PS ( bkg, U=1/16) + RR, no check Ulub < 0.69\n"); |
cprintf("\t2 - RM + PS (nobkg, U=1/16) + RR, no check Ulub < 0.69\n"); |
cprintf("\t3 - EDF + PS ( bkg, U=1/16) + RR\n"); |
cprintf("\t4 - EDF + PS (nobkg, U=1/16) + RR\n"); |
cprintf("\t5 - EDF + TBS( U=1/16) + RR\n"); |
cprintf("\t6 - RM + DS ( bkg, U=1/16) + RR, no check Ulub < 0.69\n"); |
cprintf("\t7 - RM + DS (nobkg, U=1/16) + RR, no check Ulub < 0.69\n"); |
cprintf("\nwhere <mouse-task> can be:\n"); |
cprintf("\th - Hard\n"); |
cprintf("\ts - Soft (understimated wcet)\n"); |
cprintf("\tn - NRT\n"); |
sys_end(); |
return -1; |
} |
if (grx_init() == -1) { |
cprintf("Error initing GraphLib!!!\n"); |
sys_end(); |
} |
modenum = grx_getmode(640, 480, 8); |
cprintf("Modenum :%d\n", modenum); |
if (grx_setmode(modenum) == -1) { |
cprintf("No SetMode!!!\n"); |
sys_end(); |
} |
/* this trick can be useful when debugging ... */ |
//grx_close(); |
print_grid(); |
grx_box(DX*0,240,DX*1-1,479,GREEN); |
grx_box(DX*1,240,DX*2-1,479,WHITE); |
grx_box(DX*2,240,DX*3-1,479,RED); |
grx_box(DX*3,240,DX*4-1,479,MAGENTA); |
grx_box(DX*4,240,DX*5-1,479,BLACK); |
sys_atrunlevel(my_end, NULL, RUNLEVEL_BEFORE_EXIT); |
/* mutex */ |
sem_init(&mutex,0,1); |
/* keyboard */ |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,(void (*)(KEY_EVT *))sys_end); |
keyb_getchar(); |
/* mouse */ |
mouse_init(&mouse); |
mouse_limit(XMINLIMIT(640,480), |
240, |
XMAXLIMIT(640,480), |
YMAXLIMIT(640,480)); |
mouse_position(320,280); |
mouse_threshold(2); |
//grx_setcolor(255,255,255,255); |
mouse_grxshape(mycursor,mybkg); |
mouse_grxcursor(ENABLE); |
mouse_on(); |
mouse_hook(my_mouse_handler); |
/* hard task creation */ |
hard_task_default_model(m_per); |
hard_task_def_mit(m_per,period[0]*PERIODSCALE); |
hard_task_def_wcet(m_per,ptime[0]*PERIODSCALE); |
hard_task_def_group(m_per, 1); |
//task_def_wcet(m, ptime[0] * sys_tick); |
if (task_create("verde", color, &m_per, NULL) == -1) { |
grx_close(); |
perror("Edf.C(main) Could not create <green>:"); |
sys_end(); |
} |
hard_task_def_arg(m_per, (void *)1); |
hard_task_def_wcet(m_per, ptime[1]*PERIODSCALE); |
hard_task_def_mit(m_per,period[1]*PERIODSCALE); |
if (task_create("red", color, &m_per, NULL) == -1) { |
grx_close(); |
perror("Edf.C(main) Could not create <red>:"); |
sys_end(); |
} |
hard_task_def_arg(m_per, (void *)2); |
hard_task_def_wcet(m_per, ptime[2]*PERIODSCALE); |
hard_task_def_mit(m_per,period[2]*PERIODSCALE); |
if (task_create("yellow", color, &m_per, NULL) == -1) { |
grx_close(); |
perror("Edf.C(main) Could not create <yellow>:"); |
sys_end(); |
} |
starttime = sys_gettime(NULL) / PERIODSCALE; |
group_activate(1); |
/* main loop */ |
while (x < 640L) { |
x = (sys_gettime(NULL)/PERIODSCALE - starttime) + OFFSET; |
if (x>=640) break; |
sem_wait(&mutex); |
grx_plot(x, LM, 7); |
sem_post(&mutex); |
} |
c = keyb_getchar(); |
sys_end(); |
return 0; |
} |
/*--------------------------------------------------------------*/ |
/demos/tags/rel_0_2/base/intsem.c |
---|
0,0 → 1,101 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, 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 |
* |
* |
* CVS : $Id: intsem.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
this test is a simple main() function with one other task. |
This test verify the correctness of the internal_sem functions. |
*/ |
#include "kernel/kern.h" |
#include <kernel/int_sem.h> |
internal_sem_t s; |
TASK pippo(void *a) |
{ |
int i=0; |
struct timespec t; |
do { |
sys_gettime(&t); |
if (i==0 && t.tv_sec == (int)a) { |
i = 1; |
cprintf("before internal_sem_wait %d\n",(int)a); |
internal_sem_wait(&s); |
cprintf("after internal_sem_wait %d\n",(int)a); |
} |
if (i==1 && t.tv_sec == 2+(int)a) { |
i = 2; |
cprintf("before internal_sem_post %d\n",(int)a); |
internal_sem_post(&s); |
cprintf("after internal_sem_post %d\n",(int)a); |
return 0; |
} |
} while (1); |
} |
int main(int argc, char **argv) |
{ |
NRT_TASK_MODEL m; |
PID p2,p3; |
nrt_task_default_model(m); |
nrt_task_def_group(m,1); |
nrt_task_def_arg(m,(void *)1); |
p2 = task_create("pippo1", pippo, &m, NULL); |
if (p2 == NIL) |
{ cprintf("Can't create pippo1 task...\n"); return 1; } |
nrt_task_def_arg(m,(void *)2); |
p3 = task_create("pippo2", pippo, &m, NULL); |
if (p3 == NIL) |
{ cprintf("Can't create pippo2 task...\n"); return 1; } |
internal_sem_init(&s,1); |
group_activate(1); |
return 0; |
} |
/demos/tags/rel_0_2/base/isched.c |
---|
0,0 → 1,207 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: isched.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-11-11 08:22:45 $ |
------------ |
System initialization file |
The tick is set to TICK ms. |
This file contains the 2 functions needed to initialize the system. |
These functions register the following levels: |
an EDF (Earliest Deadline First) level |
a RR (Round Robin) level |
a CBS (Costant Bandwidth Server) level |
a Dummy level |
It can accept these task models: |
HARD_TASK_MODEL (wcet+mit) at level 0 |
NRT_TASK_MODEL at level 1 |
SOFT_TASK_MODEL (met, period) at level 2 |
This file is similar to the configuration of Hartik 3.3.1 |
**/ |
/* |
* 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 "modules/edf.h" |
#include "modules/rm.h" |
#include "modules/cbs.h" |
#include "modules/tbs.h" |
#include "modules/ps.h" |
#include "modules/ds.h" |
#include "modules/rr.h" |
#include "modules/rr2.h" |
#include "modules/dummy.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "drivers/keyb.h" |
/*+ sysyem tick in us +*/ |
#define TICK 300 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
/* the mouse task use 160 us approx on my Celeron 366 */ |
#define NUM 2000 |
#define DEN 64000 |
//#define DEN 8000 |
//#undef XXX |
//#define XXX |
int argc; |
char *argv[100]; |
extern char *title; |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
int conf; |
__compute_args__(mb,&argc, argv); |
if (argc < 2) |
conf = '0'; // default |
else |
conf = *argv[1]; |
switch (conf) { |
case '1': |
RM_register_level(0); // NO GUARANTEE!!! |
PS_register_level(PS_ENABLE_BACKGROUND, 0, NUM, DEN); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
title = "1 - RM + PS ( bkg, U=1/16) + RR, no check Ulub < 0.69"; |
break; |
case '2': |
RM_register_level(0); // NO GUARANTEE!!! |
PS_register_level(0, 0, NUM, DEN); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
title = "2 - RM + PS (nobkg, U=1/16) + RR, no check Ulub < 0.69\n"; |
break; |
case '3': |
EDF_register_level(2); |
PS_register_level(PS_ENABLE_ALL_EDF, 0, NUM, DEN); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
title = "3 - EDF + PS ( bkg, U=1/16) + RR"; |
break; |
case '4': |
EDF_register_level(2); |
PS_register_level(PS_ENABLE_GUARANTEE_EDF, 0, NUM, DEN); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
title = "4 - EDF + PS (nobkg, U=1/16) + RR"; |
break; |
case '5': |
EDF_register_level(2); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
TBS_register_level(TBS_ENABLE_ALL, 0, NUM, DEN); |
title = "5 - EDF + TBS( U=1/16) + RR"; |
break; |
case '6': |
RM_register_level(0); // NO GUARANTEE!!! |
DS_register_level(DS_ENABLE_BACKGROUND, 0, NUM, DEN); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
title = "6 - RM + DS ( bkg, U=1/16) + RR, no check Ulub < 0.69"; |
break; |
case '7': |
RM_register_level(0); // NO GUARANTEE!!! |
DS_register_level(0, 0, NUM, DEN); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
title = "7 - RM + DS (nobkg, U=1/16) + RR, no check Ulub < 0.69\n"; |
break; |
default: // '0' |
EDF_register_level(2); |
RR2_register_level(RRTICK, RR2_MAIN_YES, mb); |
CBS_register_level(CBS_ENABLE_ALL, 0); |
title = "0 - EDF + CBS + RR"; |
} |
dummy_register_level(); |
SEM_register_module(); |
CABS_register_module(); |
return TICK; |
} |
int main(int argc, char **argv); |
TASK __init__(void *arg) |
{ |
// struct multiboot_info *mb = (struct multiboot_info *)arg; |
HARTPORT_init(); |
KEYB_init(NULL); |
main(argc,argv); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/pcdemo.c |
---|
0,0 → 1,212 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: pcdemo.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
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 |
*/ |
#include "kernel/kern.h" |
#include "drivers/keyb.h" |
mutex_t m0,m1,m2; |
void startJ(void *a) |
{ |
task_activate((PID)a); |
} |
TASK j0() |
{ |
cprintf("J0: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J0: locked m0\n"); |
mutex_unlock(&m0); |
cprintf("J0: unlocked m0, locking m1\n"); |
mutex_lock(&m1); |
cprintf("J0: locked m1\n"); |
mutex_unlock(&m1); |
cprintf("J0: unlocked m1, end task\n"); |
return 0; |
} |
TASK j1() |
{ |
cprintf("J1: before locking m2\n"); |
mutex_lock(&m2); |
cprintf("J1: locked m2\n"); |
mutex_unlock(&m2); |
cprintf("J1: unlocked m2, end task\n"); |
return 0; |
} |
TASK j2() |
{ |
cprintf("J2: before locking m2\n"); |
mutex_lock(&m2); |
cprintf("J2: locked m2, waiting to t=1 sec\n"); |
while (sys_gettime(NULL) < 1000000); |
cprintf("J2: t = 1 sec reached\n"); |
mutex_lock(&m1); |
cprintf("J2: locked m1, waiting to t=2 sec\n"); |
while (sys_gettime(NULL) < 2000000); |
cprintf("J2: t = 2 sec reached\n"); |
mutex_unlock(&m1); |
cprintf("J2: unlocked m1\n"); |
mutex_unlock(&m2); |
cprintf("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; |
cprintf("Priority Ceiling demo. Press Alt-X to exit the demo\n"); |
//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) |
{ cprintf("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) |
{ cprintf("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) |
{ cprintf("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; |
kern_cli(); |
kern_event_post(&t,startJ,(void *)p1); |
t.tv_sec = 1; |
kern_event_post(&t,startJ,(void *)p0); |
kern_sti(); |
task_activate(p2); |
cprintf("END main\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/srpdemo.c |
---|
0,0 → 1,244 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: srpdemo.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
This test verify the correctness of the SRP module. |
There are 3 taks, Jh, Jm, Jl that uses 3 mutexes m1, m2, m3 |
the main task (NRT) creates the three tasks. |
Jh with preemption level 3 |
starts at t=1.5 sec and lock m3, lock m1, unlock m1, unlock m3 |
Jm with preemption level 2 |
starts at t=0.5 sec and lock m3, lock m2, unlock m2, unlock m3 |
then lock and unlock m1 |
Jl with preemption level 1 |
it starts and locks m2 |
at t=1 sec it locks m1 |
at t=1.5 sec it unlocks m1 |
then it unlocks m2, and finally it locks and unlocks m3 |
The example is similar to the scheduling diagram shown at p. 210 of the |
book "Sistemi in tempo Reale", by Giorgio Buttazzo, Pitagora Editrice |
*/ |
#include "kernel/kern.h" |
#include "drivers/keyb.h" |
#include "modules/srp.h" |
mutex_t m1,m2,m3; |
void startJ(void *a) |
{ |
task_activate((PID)a); |
} |
TASK Jlobby() |
{ |
cprintf("(*) JLobby!!!\n"); |
return 0; |
} |
TASK Jh() |
{ |
PID l; |
HARD_TASK_MODEL m; |
SRP_RES_MODEL r; |
cprintf("JH: creating Jy before locking m3\n"); |
hard_task_default_model(m); |
hard_task_def_mit(m,30000); |
hard_task_def_wcet(m,1000); |
SRP_res_default_model(r,4); |
l = task_create("Jlobby",Jlobby,&m,&r); |
task_activate(l); |
mutex_lock(&m3); |
cprintf("JH: locked m3, locking m1\n"); |
mutex_lock(&m1); |
cprintf("JH: locked m1, unlocking m1\n"); |
mutex_unlock(&m1); |
cprintf("JH: unlocked m1, unlocking m3\n"); |
mutex_unlock(&m3); |
cprintf("JH: unlocked m3, end task\n"); |
return 0; |
} |
TASK Jm() |
{ |
cprintf("JM: before locking m3\n"); |
mutex_lock(&m3); |
cprintf("JM: locked m3, locking m2\n"); |
mutex_lock(&m2); |
cprintf("JM: locked m2, unlocking m2\n"); |
mutex_unlock(&m2); |
cprintf("JM: unlocked m2, unlocking m3\n"); |
mutex_unlock(&m3); |
cprintf("JM: unlocked m3, locking m1\n"); |
mutex_lock(&m1); |
cprintf("JM: locked m1, unlocking m1\n"); |
mutex_unlock(&m1); |
cprintf("JM: unlocked m1, end task\n"); |
return 0; |
} |
TASK Jl() |
{ |
cprintf("JL: before locking m2\n"); |
mutex_lock(&m2); |
cprintf("JL: locked m2, waiting to t=1 sec\n"); |
while (sys_gettime(NULL) < 1000000); |
cprintf("JL: t = 1 sec reached, locking m1\n"); |
mutex_lock(&m1); |
cprintf("JL: locked m1, waiting to t=2 sec\n"); |
while (sys_gettime(NULL) < 2000000); |
cprintf("JL: t = 2 sec reached, unlocking m1\n"); |
mutex_unlock(&m1); |
cprintf("JL: unlocked m1, unlocking m2\n"); |
mutex_unlock(&m2); |
cprintf("JL: unlocked m2, locking m3\n"); |
mutex_lock(&m3); |
cprintf("JL: locked m3, unlocking m3\n"); |
mutex_unlock(&m3); |
cprintf("JL: unlocked m3, 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; |
SRP_mutexattr_t a; |
SRP_RES_MODEL r; |
PI_mutexattr_t a2; |
KEY_EVT emerg; |
cprintf("Stack resource Policy demo. Press Alt-X to exit the demo\n"); |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
/* --------------------------------------------------------------------- |
Mutex creation |
--------------------------------------------------------------------- */ |
PI_mutexattr_default(a2); |
SRP_mutexattr_default(a); |
mutex_init(&m1,&a); |
mutex_init(&m2,&a); |
mutex_init(&m3,&a); |
/* --------------------------------------------------------------------- |
Task creation |
--------------------------------------------------------------------- */ |
hard_task_default_model(m); |
hard_task_def_mit(m, 1000000); |
hard_task_def_wcet(m, 80000); |
SRP_res_default_model(r, 3); |
p0 = task_createn("JH", Jh, (TASK_MODEL *)&m, &r, SRP_usemutex(&m3), SRP_usemutex(&m1), NULL); |
if (p0 == NIL) |
{ cprintf("Can't create JH task...\n"); return 1; } |
hard_task_default_model(m); |
hard_task_def_mit(m, 2100000); |
hard_task_def_wcet(m, 80000); |
SRP_res_default_model(r, 2); |
p1 = task_createn("JM", Jm, (TASK_MODEL *)&m, &r, SRP_usemutex(&m3), SRP_usemutex(&m1), |
SRP_usemutex(&m2), NULL); |
if (p1 == NIL) |
{ cprintf("Can't create JM task...\n"); return 1; } |
hard_task_default_model(m); |
hard_task_def_mit(m, 10000000); |
hard_task_def_wcet(m, 3000000); |
SRP_res_default_model(r, 1); |
p2 = task_createn("JL", Jl, (TASK_MODEL *)&m, &r, SRP_usemutex(&m3), SRP_usemutex(&m1), |
SRP_usemutex(&m2), NULL); |
if (p2 == NIL) |
{ cprintf("Can't create JL task...\n"); return 1; } |
/* --------------------------------------------------------------------- |
Event post |
--------------------------------------------------------------------- */ |
t.tv_sec = 0; |
t.tv_nsec = 500000000; |
kern_cli(); |
kern_event_post(&t,startJ,(void *)p1); |
t.tv_sec = 1; |
kern_event_post(&t,startJ,(void *)p0); |
kern_sti(); |
task_activate(p2); |
cprintf("END main\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/iaster4.c |
---|
0,0 → 1,133 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: iaster4.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-11-11 08:22:45 $ |
------------ |
System initialization file |
The tick is set to TICK ms. |
This file contains the 2 functions needed to initialize the system. |
These functions register the following levels: |
an EDF (Earliest Deadline First) level |
a RR (Round Robin) level |
a TBS (Total Bandwidth Server) level 0.1 Us |
a TBS (Total Bandwidth Server) level 0.3 Us |
a CBS (Constant Bandwidth Server) level |
a Dummy level |
The TBS bandwidth is TBS_NUM/TBS_DEN |
It can accept these task models (into () the mandatory fields): |
HARD_TASK_MODEL (wcet+mit) at level 0 |
NRT_TASK_MODEL at level 1 |
SOFT_TASK_MODEL (wcet, periodicity=APERIODIC) at level 2,3 |
SOFT_TASK_MODEL (met,period) at level 4 |
**/ |
/* |
* 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 "modules/edf.h" |
#include "modules/rr.h" |
#include "modules/tbs.h" |
#include "modules/cbs.h" |
#include "modules/rrsoft.h" |
#include "modules/dummy.h" |
#include "drivers/keyb.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
/*+ sysyem tick in us +*/ |
//#define TICK 300 |
#define TICK 0 |
#define RRTICK 5000 |
#define TBS_NUM 1 |
#define TBS_DEN 10 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
TBS_register_level(TBS_ENABLE_ALL, 0, TBS_NUM, TBS_DEN); |
TBS_register_level(TBS_ENABLE_ALL, 0, TBS_NUM*3, TBS_DEN); |
CBS_register_level(CBS_ENABLE_ALL, 0); |
/* RRSOFT_register_level(RRTICK, RR_MAIN_NO, mb, RRSOFT_ONLY_HARD); |
RR_register_level(RRTICK, RR_MAIN_NO, mb); |
RRSOFT_register_level(RRTICK, RR_MAIN_NO, mb, RRSOFT_ONLY_SOFT); //cbs |
RRSOFT_register_level(RRTICK, RR_MAIN_NO, mb, RRSOFT_ONLY_SOFT); //tbs |
RRSOFT_register_level(RRTICK, RR_MAIN_NO, mb, RRSOFT_ONLY_SOFT); //tbs |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
*/ |
dummy_register_level(); |
SEM_register_module(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
HARTPORT_init(); |
KEYB_init(NULL); |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/preempt.c |
---|
0,0 → 1,147 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: preempt.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
CBS test with preemption disabling |
*/ |
#include "kernel/kern.h" |
void *periodic(void *arg) |
{ |
int i; |
int y = (int)arg; |
for (i = 19; i < 60; i++) { |
puts_xy(i,y,7,"*"); |
task_endcycle(); |
} |
return 0; |
} |
void *blocker(void *arg) |
{ |
struct timespec t; |
task_nopreempt(); |
cprintf("Blocker: Task nopreempt\n"); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < 5); |
cprintf("Blocker: Task preempt\n"); |
task_preempt(); |
cprintf("Blocker: end\n"); |
return 0; |
} |
int main(int argc, char **argv) |
{ |
struct timespec t; |
NRT_TASK_MODEL m; |
SOFT_TASK_MODEL m_aper; |
PID p; |
clear(); |
cprintf("Preemption Test.\n"); |
cprintf("Start time: two periodic tasks and a blocker are created and activated.\n"); |
cprintf("2 seconds : blocker calls task_nopreempt.\n"); |
cprintf("5 seconds : task_preempt is called.\n"); |
cprintf(" The blocked task exec its pending activations.\n"); |
cprintf("10 seconds: the test stops.\n"); |
puts_xy(1,20,7,"save task:"); |
puts_xy(1,21,7,"skip task:"); |
nrt_task_default_model(m); |
soft_task_default_model(m_aper); |
soft_task_def_met(m_aper,10000); |
soft_task_def_period(m_aper,200000); |
soft_task_def_group(m_aper,1); |
soft_task_def_arg(m_aper, (void *)20); |
soft_task_def_periodic(m_aper); |
p = task_create("save", periodic, &m_aper, NULL); |
if (p == NIL) |
{ |
perror("Can't create save task...\n"); |
sys_end(); |
} |
soft_task_def_skip_arrivals(m_aper); |
soft_task_def_arg(m_aper, (void *)21); |
p = task_create("skip", periodic, &m_aper, NULL); |
if (p == NIL) |
{ |
perror("Can't create skip task...\n"); |
sys_end(); |
} |
p = task_create("blocker", blocker, &m, NULL); |
if (p == NIL) |
{ |
perror("Can't create blocker task...\n"); |
sys_end(); |
} |
cprintf("main : save & skip tasks activated.\n"); |
group_activate(1); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < 2); |
cprintf("main : blocker activated.\n"); |
task_activate(p); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < 10); |
cprintf("main : End!!!\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/iaster6.c |
---|
0,0 → 1,130 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: iaster6.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-11-11 08:22:45 $ |
------------ |
System initialization file |
h3pips.c |
These functions register the following levels: |
an EDF (Earliest Deadline First) level |
a RR (Round Robin) level |
a CBS (Costant Bandwidth Server) level |
a PS (Polling Server) level |
a Dummy level |
It can accept these task models: |
HARD_TASK_MODEL (wcet+mit) at level 0 |
NRT_TASK_MODEL at level 1 |
SOFT_TASK_MODEL (met, period) at level 2 |
SOFT_TASK_MODEL (periodicity=APERIODIC) at level 3 |
**/ |
/* |
* 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 "modules/edf.h" |
#include "modules/cbs.h" |
#include "modules/rr.h" |
#include "modules/dummy.h" |
#include "modules/ps.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "modules/pi.h" |
#include "modules/pc.h" |
#include "modules/srp.h" |
#include "modules/npp.h" |
#include "modules/nop.h" |
#include "drivers/keyb.h" |
/*+ sysyem tick in us +*/ |
#define TICK 1000 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
CBS_register_level(CBS_ENABLE_ALL, 0); |
PS_register_level(2 /*PS_ENABLE_ALL_EDF*/,0,500,100000); |
dummy_register_level(); |
SEM_register_module(); |
CABS_register_module(); |
PI_register_module(); |
PC_register_module(); |
NPP_register_module(); |
SRP_register_module(); |
NOP_register_module(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
HARTPORT_init(); |
KEYB_init(NULL); |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/pidemo.c |
---|
0,0 → 1,116 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: pidemo.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
This test verify the correctness of the PI module. |
the main task (NRT) lock a PI mutex. |
then 2 tasks arrives, with priority higher than the main |
the first try to lock the mutex, but it can't, so the main inherit |
his priority. The second simply prints a string. |
If all works, the string of the second task is printed after the end of |
the first task. |
*/ |
#include "kernel/kern.h" |
mutex_t m1; |
TASK goofy1(void *a) |
{ |
cprintf("goofy1 before mutex_lock\n"); |
mutex_lock(&m1); |
cprintf("goofy1 after mutex_lock\n"); |
mutex_unlock(&m1); |
cprintf("goofy1 after mutex_unlock\n"); |
return 0; |
} |
TASK goofy2() |
{ |
cprintf("goofy2 inside goofy2\n"); |
return 0; |
} |
int main(int argc, char **argv) |
{ |
HARD_TASK_MODEL m; |
PID p2,p3; |
PI_mutexattr_t a; |
set_exchandler_grx(); |
hard_task_default_model(m); |
hard_task_def_mit(m,50000); |
hard_task_def_wcet(m,20000); |
hard_task_def_group(m,1); |
hard_task_def_arg(m,(void *)1); |
p2 = task_create("goofy1", goofy1, &m, NULL); |
if (p2 == NIL) |
{ cprintf("Can't create goofy1 task...\n"); return 1; } |
hard_task_def_mit(m,100000); |
p3 = task_create("goofy2", goofy2, &m, NULL); |
if (p3 == NIL) |
{ cprintf("Can't create goofy2 task...\n"); return 1; } |
PI_mutexattr_default(a); |
mutex_init(&m1,&a); |
cprintf("main before mutex_lock\n"); |
mutex_lock(&m1); |
cprintf("main after mutex_lock\n"); |
group_activate(1); |
cprintf("main after group_activate\n"); |
mutex_unlock(&m1); |
cprintf("main after mutex_unlock\n"); |
mutex_destroy(&m1); |
cprintf("main after mutex_destroy\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/iaster7.c |
---|
0,0 → 1,144 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: iaster7.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-11-11 08:22:45 $ |
------------ |
System initialization file |
The tick is set to TICK ms. |
This file contains the 2 functions needed to initialize the system. |
These functions register a set of scheduling modules, in a fixed or |
dynamic priority way... |
It can accept these task models: |
HARD_TASK_MODEL (wcet+mit) at level 0 |
SOFT_TASK_MODEL (periodicity=APERIODIC) at level 1 |
NRT_TASK_MODEL at level 2 |
SOFT_TASK_MODEL (periodicity=APERIODIC, wcet (only if TBS) ) at level 3,4 |
**/ |
/* |
* 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 "modules/edf.h" |
#include "modules/tbs.h" |
#include "modules/rm.h" |
#include "modules/rr.h" |
#include "modules/ps.h" |
#include "modules/dummy.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
#include "drivers/keyb.h" |
#include <ll/stdio.h> |
/*+ sysyem tick in us +*/ |
#define TICK 300 |
#define RRTICK 5000 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
// EDF_register_level(EDF_ENABLE_ALL); |
// PS_register_level(2 /*PS_ENABLE_ALL_EDF*/,0,1000,100000); |
// RR_register_level(RRTICK, RR_MAIN_YES, mb); |
// TBS_register_level(TBS_ENABLE_ALL, 0, 1, 10); |
// PS_register_level(2,0,3000,10000); |
// TBS_register_level(TBS_ENABLE_ALL, 0, 3, 10); |
RM_register_level(RM_ENABLE_ALL); |
PS_register_level(PS_ENABLE_ALL_RM,0,1000,100000); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
PS_register_level(4,0,10000,100000); |
PS_register_level(4,0,30000,100000); |
dummy_register_level(); |
SEM_register_module(); |
return TICK; |
} |
SOFT_TASK_MODEL m; |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
KEYB_PARMS k = BASE_KEYB; |
soft_task_default_model(m); |
soft_task_def_wcet(m,2000); |
soft_task_def_met(m,800); |
soft_task_def_period(m,25000); |
soft_task_def_system(m); |
soft_task_def_nokill(m); |
soft_task_def_aperiodic(m); |
soft_task_def_level(m,4); |
keyb_def_task(k,&m); |
HARTPORT_init(); |
if (KEYB_init(&k) < 0) |
cprintf("Error during the init of the Keyboard!!!"); |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/aster.c |
---|
0,0 → 1,423 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Paolo Gai, Gerardo Lamastra and Giuseppe Lipari |
* |
* 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 |
* |
* |
* CVS : $Id: aster.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
Author: Gerardo Lamastra |
Giuseppe Lipari |
Date: 1/10/96 |
File: Aster.C |
Revision: 1.6 |
*/ |
/* |
Well, this is only a stupid demo which intend to show many |
HARTIK+ capabilities; the application is structured in the followig |
way: there is an ASTER task wich randomly creates some ASTEROID tasks |
which are displayed into the first window; each task is HARD/PERIODIC |
and auto-kills itself when it reaches the window end! |
An other couple of tasks, TITLE & PUT give an example of port |
communication facility; the server task creates the port, the client |
task connect to it and uses the server to accomplish some stuff. |
Port can be declared READ/WRITE and can model ONE-TO-ONE communication |
or MANY-TO-ONE communication. |
Finally a second couple of tasks realizes a communiation through CABs; |
each time a key is pressed, the ascii code is posted into the CAB by the |
CCC task while the second task, WRITE, displays it on the screen and |
perform other silly actions. |
Finally a CLOCK task is implemented to test system clock. |
Please note that usually the HARTIK+ application is made up of a task |
group which interacts among them, while the main() function, which |
became a task itself when the kernel is activated, is suspended until |
the system is ready to terminate; the MAIN task can also be used to make |
other background activities, but it should not be killed; when the |
application terminates, the control is passed to MAIN which kills |
everybody, shut down the system and can handle other operations using |
the services available with the previou operating system (I.E. the DOS). |
If you need to manage sudden abort/exception you should install your own |
exception handler and raise it through the exc_raise() primitive to |
make the system abort safely! |
Remember that the exit functions posted through sys_atexit() will be |
executed in both cases, to allow clean system shutdown. |
*/ |
//#include <string.h> |
//#include <stdlib.h> |
#include <kernel/kern.h> |
#include <modules/sem.h> |
#include <modules/hartport.h> |
#include <modules/cabs.h> |
#include <drivers/keyb.h> |
#include <string.h> |
#define __VPAGING__ |
#include <drivers/keyb.h> |
#include <drivers/crtwin.h> |
int num_aster = 0; |
#define ASTER_LIM 67 |
CAB cc; |
BYTE esc = FALSE; |
TASK asteroide(void) |
{ |
int i = 1; |
int y = rand() % 7 + 1; |
while (i < ASTER_LIM) { |
puts_xy(i,y,WHITE,"*"); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
num_aster--; |
return 0; |
} |
DWORD taskCreated = 0; |
TASK aster(void) |
{ |
PID p; |
SOFT_TASK_MODEL m_soft; |
int r; |
WIN w; |
win_init(&w,0,0,ASTER_LIM,8); |
win_frame(&w,BLACK,WHITE,"Asteroids",2); |
soft_task_default_model(m_soft); |
soft_task_def_met(m_soft,2000); |
soft_task_def_ctrl_jet(m_soft); |
srand(7); |
while (1) { |
if (num_aster < 5) { |
r = (rand() % 50) - 25; |
soft_task_def_arg(m_soft,(void *)((rand() % 7)+1)); |
soft_task_def_period(m_soft,(50 + r)*1000); |
p = task_create("aaa",asteroide,(TASK_MODEL *)&m_soft,NULL); |
taskCreated++; |
task_activate(p); |
num_aster++; |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
WIN w; |
int s = 0, m = 0; |
win_init(&w,68,0,11,2); |
win_frame(&w,BLACK,WHITE,"Clk",1); |
while(1) { |
printf_xy(70,1,WHITE,"%2d : %2d",m,s); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
printf_xy(70,1,WHITE,"%2d : %2d",m,s); |
task_endcycle(); |
} |
} |
TASK title() |
{ |
PORT t; |
WIN w; |
int i,pos = 77; |
char msg[85],tmp[85],ss[2]; |
BYTE c; |
win_init(&w,0,9,79,2); |
win_frame(&w,BLACK,WHITE,"Title",2); |
for (i=0; i < 77; i++) msg[i] = ' '; |
msg[77] = 0; |
t = port_connect("title",1,STREAM,READ); |
while (1) { |
port_receive(t,&c,BLOCK); |
ss[0] = c; |
ss[1] = 0; |
strcat(msg,ss); |
puts_xy(1,10,WHITE,msg); |
pos++; |
if (pos > 77) { |
strcpy(tmp,&(msg[1])); |
tmp[pos-1] = 0; |
pos -= 1; |
strcpy(msg,tmp); |
} |
task_endcycle(); |
} |
} |
#define STR "..................... Hartik+ ....................."\ |
" Guarantees hard tasks "\ |
" Includes soft periodic tasks "\ |
"TB server for decrementing the aperiodic response time "\ |
"SRP for both hard & soft aperiodic tasks "\ |
"Portability toward other compilers/system "\ |
"Support for different C compiler: Watcom C 16 bit & 32 bit"\ |
" -- GNU C (32 bit) -- Borland C (16 bit) -- MS C (16 bit)"\ |
" "\ |
"Programmers : Gerardo Lamastra (lamastra@sssup2.sssup.it) "\ |
" Giuseppe Lipari (lipari@sssup2.sssup.it) "\ |
"Alpha AXP PCI-33 porting by Antonino Casile "\ |
"(casile@sssup1.sssup.it) "\ |
"Research coordinator: Giorgio Buttazzo (giorgio@sssup1.sssup.it)"\ |
" "\ |
" "\ |
" " |
static char GreetMsg[1600]; |
TASK put(void) |
{ |
PORT p; |
strcpy(GreetMsg,STR); |
p = port_create("title",strlen(GreetMsg),1,STREAM,WRITE); |
while(1) { |
port_send(p,GreetMsg,BLOCK); |
task_endcycle(); |
} |
} |
TASK ccc(void) |
{ |
WIN w; |
char *m; |
win_init(&w,68,3,10,3); |
win_frame(&w,BLACK,WHITE,"CCC",2); |
puts_xy(70,4,WHITE,"Cab"); |
while(1) { |
m = cab_getmes(cc); |
puts_xy(72,5,WHITE,m); |
cab_unget(cc,m); |
task_endcycle(); |
} |
} |
TASK write_keyb() |
{ |
BYTE c; |
char *msg; |
while (1) { |
c = keyb_getchar(); |
if (c == ESC) { |
esc = TRUE; |
task_sleep(); |
} |
else { |
#ifdef __VPAGING__ |
if (c == 's') { |
if (get_visual_page() == 0) set_visual_page(1); |
else if (get_visual_page() == 1) set_visual_page(0); |
} |
#endif |
msg = cab_reserve(cc); |
msg[0] = c; |
msg[1] = 0; |
cab_putmes(cc,msg); |
} |
} |
} |
#define DELTA 200000.0 |
double carico(double rif,BYTE init) |
{ |
double i; |
DWORD t1 = 0,t2 = 1000; |
double u; |
i = 0.0; |
do { |
i += 1; |
} while (i <= DELTA); |
u = i / ((double) (t2 - t1)); |
if (init) return u; |
else return (1.0 - u/rif); |
} |
void my_end(KEY_EVT *e) |
{ |
set_active_page(0); |
set_visual_page(0); |
cprintf("Ctrl-Brk pressed!\n"); |
sys_end(); |
} |
void res(void *arg) |
{ |
sys_status(CLOCK_STATUS|SCHED_STATUS); |
} |
int main(int argc, char **argv) |
{ |
PID p1,p2,p3,p4,p5,p6; |
HARD_TASK_MODEL m_per; |
SOFT_TASK_MODEL m_soft; |
NRT_TASK_MODEL m_nrt; |
KEY_EVT emerg; |
// double rif; |
struct timespec t; |
sys_atrunlevel(res, NULL, RUNLEVEL_BEFORE_EXIT); |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,my_end); |
#ifdef __VPAGING__ |
set_active_page(1); |
set_visual_page(1); |
#endif |
CRSR_OFF(); |
clear(); |
puts_xy(0,20,WHITE,"Press ESC to exit demo."); |
cc = cab_create("Cab",2,2); |
soft_task_default_model(m_soft); |
soft_task_def_period(m_soft,500000); |
soft_task_def_met(m_soft,1000); |
soft_task_def_group(m_soft, 1); |
p1 = task_create("Aster",aster,&m_soft,NULL); |
if (p1 == -1) { |
perror("Aster.C(main): Could not create task <aster>"); |
sys_abort(-1); |
} |
hard_task_default_model(m_per); |
hard_task_def_mit(m_per,500000); |
hard_task_def_wcet(m_per,1000); |
hard_task_def_group(m_per, 1); |
p2 = task_create("Clock",clock,&m_per,NULL); |
if (p2 == -1) { |
perror("Aster.C(main): Could not create task <Clock>"); |
sys_abort(-1); |
} |
soft_task_def_period(m_soft, 50000); |
p3 = task_create("Title",title,&m_soft, NULL); |
if (p3 == -1) { |
perror("Aster.C(main): Could not create task <Title>"); |
sys_abort(-1); |
} |
soft_task_def_period(m_soft, 1000000); |
p4 = task_create("Put",put,&m_soft, NULL); |
if (p4 == -1) { |
perror("Aster.C(main): Could not create task <Put>"); |
sys_abort(-1); |
} |
nrt_task_default_model(m_nrt); |
nrt_task_def_group(m_nrt, 1); |
p5 = task_create("Write",write_keyb,&m_nrt,NULL); |
if (p5 == -1) { |
perror("Aster.C(main): Could not create task <Write>"); |
sys_abort(-1); |
} |
hard_task_def_mit(m_per, 50000); |
p6 = task_create("CabTask",ccc,&m_per,NULL); |
if (p6 == -1) { |
perror("Aster.C(main): Could not create task <CabTask>\n"); |
sys_abort(-1); |
} |
/* |
task_activate(p1); |
task_activate(p2); |
task_activate(p3); |
task_activate(p4); |
task_activate(p5); |
task_activate(p6); |
*/ |
group_activate(1); |
while (!esc) { |
kern_cli(); |
ll_gettime(TIME_EXACT,&t); |
kern_sti(); |
printf_xy(0,21,WHITE,"Clock : %-9ds %-9dns",(int)t.tv_sec, (int)t.tv_nsec); |
} |
group_kill(1); |
clear(); |
CRSR_STD(); |
#ifdef __VPAGING__ |
set_active_page(0); |
set_visual_page(0); |
#endif |
cprintf("System closed\n"); |
sys_end(); |
/* |
sys_status(NORM_STATUS|BLOCKED_STATUS|SLEEP_STATUS|IDLE_STATUS); |
sys_status(NORM_STATUS|SLEEP_STATUS); |
*/ |
return 0; |
} |
/demos/tags/rel_0_2/base/iaster8.c |
---|
0,0 → 1,128 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: iaster8.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-11-11 08:22:45 $ |
------------ |
System initialization file |
h3piss.c |
These functions register the following levels: |
an EDF (Earliest Deadline First) level |
a CBS (Costant Bandwidth Server) level |
a SS (Sporadic Server) level |
a RR (Round Robin) level |
a Dummy level |
It can accept these task models: |
HARD_TASK_MODEL (wcet+mit) at level 0 |
SOFT_TASK_MODEL (met, period) at level 1 |
SOFT_TASK_MODEL (periodicity=APERIODIC) at level 2 |
NRT_TASK_MODEL at level 3 |
**/ |
/* |
* 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 "modules/rm.h" |
#include "modules/edf.h" |
#include "modules/cbs.h" |
#include "modules/rr.h" |
#include "modules/dummy.h" |
#include "modules/ss.h" |
#include "modules/sem.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "modules/pi.h" |
#include "modules/pc.h" |
#include "modules/srp.h" |
#include "modules/npp.h" |
#include "modules/nop.h" |
#include "drivers/keyb.h" |
/*+ system tick in us +*/ |
#define TICK 1000 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
CBS_register_level(CBS_ENABLE_ALL, 0); |
SS_register_level(SS_ENABLE_GUARANTEE_EDF,0,5000,20000); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
dummy_register_level(); |
SEM_register_module(); |
CABS_register_module(); |
PC_register_module(); |
PI_register_module(); |
NPP_register_module(); |
SRP_register_module(); |
NOP_register_module(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
HARTPORT_init(); |
KEYB_init(NULL); |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/pcidemo.c |
---|
0,0 → 1,86 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Paolo Gai, Luca Abeni |
* |
* 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 |
* |
* |
* CVS : $Id: pcidemo.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
This is the pcitest Hartik's example. |
*/ |
#include "kernel/kern.h" |
#include "drivers/keyb.h" |
#include "drivers/llpci.h" |
#include "drivers/pci.h" |
void scan() |
{ |
BYTE bus, dev; |
/* Scan the devices connected to the PCI bus */ |
if (pci_init() == 1) { |
clear(); |
pci_show(); |
bus = 0; dev = 0; |
if (pcibios_find_device(0x8086, 0x7000, 0, &bus, &dev) == NULL) |
cprintf("Not found... %d %d\n", bus, dev); |
else cprintf("Found: %d \t %d\n", bus, dev); |
if (pcibios_find_class(0x300, 0, &bus, &dev) == NULL) |
cprintf("Not found... %d %d\n", bus, dev); |
else cprintf("Found: %d \t %d\n", bus, dev); |
} else cprintf("PCI not found!!!\n"); |
} |
void endfun(KEY_EVT *k) |
{ |
sys_end(); |
} |
int main (int argc, char *argv[]) |
{ |
KEY_EVT k; |
k.flag = CNTR_BIT; |
k.scan = KEY_C; |
k.ascii = 'c'; |
keyb_hook(k,endfun); |
scan(); |
sys_end(); |
return 0; |
} |
/demos/tags/rel_0_2/base/condtest.c |
---|
0,0 → 1,222 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, 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 |
* |
* |
* CVS : $Id: condtest.c,v 1.1 2002-11-11 08:22:45 pj Exp $ |
This test verify the correctness of the condition variables. |
(... it doesn't test all...) |
The test uses 1 mutex |
the main task (NRT) creates three tasks. |
J0, J1, J3 |
starts, lock the mutex, and wait on a condition variable |
J2 |
at t = 0.5 lock the mutex and call cond_signal |
at t = 1 lock the mutex and call cond_signal |
*/ |
#include "kernel/kern.h" |
#include "drivers/keyb.h" |
mutex_t m0; |
cond_t c0; |
int number = 0; |
PID p0,p1,p2,p3; |
TASK j0() |
{ |
cprintf("J0: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J0: locked m0, waiting on c0, number =%d\n", number); |
while (!number) { |
cond_wait(&c0,&m0); |
cprintf("J0: number = %d, if >0 unlocking m0\n",number); |
} |
number--; |
mutex_unlock(&m0); |
cprintf("J0: unlocked m0, end task\n"); |
return 0; |
} |
TASK j1() |
{ |
cprintf("J1: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J1: locked m0, waiting on c0, number =%d\n", number); |
while (!number) { |
cond_wait(&c0,&m0); |
cprintf("J1: number = %d, if >0 unlocking m0\n",number); |
} |
number--; |
mutex_unlock(&m0); |
cprintf("J1: unlocked m0, end task\n"); |
return 0; |
} |
TASK j2() |
{ |
// struct timespec t; |
cprintf("J2: started, waiting t=0.5 sec\n"); |
while (sys_gettime(NULL) < 500000); |
cprintf("J2: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J2: locked m0, number++ (was %d), cond_signal\n", number); |
number++; |
cond_signal(&c0); |
// cond_broadcast(&c0); |
cprintf("J2: unlocking m0\n"); |
mutex_unlock(&m0); |
cprintf("J2: waiting t=1 sec\n"); |
while (sys_gettime(NULL) < 1000000); |
cprintf("J2: Killing J3\n"); |
task_kill(p3); |
cprintf("J2: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J2: locked m0, number++ (was %d), cond_signal\n", number); |
number++; |
cond_signal(&c0); |
// cond_broadcast(&c0); |
cprintf("J2: unlocking m0\n"); |
mutex_unlock(&m0); |
cprintf("J2: unlocked m0, end task\n"); |
return 0; |
} |
void cleanup_lock(void *arg) |
{ |
cprintf("J3: KILL!!!\n"); |
mutex_unlock(&m0); |
cprintf("J3: unlocked m0 by the cleanup function\n"); |
} |
TASK j3() |
{ |
cprintf("J3: before locking m0\n"); |
mutex_lock(&m0); |
cprintf("J3: locked m0, waiting on c0, number =%d\n", number); |
task_cleanup_push(cleanup_lock, (void *)&m0); |
while (!number) { |
cond_wait(&c0,&m0); |
cprintf("J3: number = %d, if >0 unlocking m0\n",number); |
} |
task_cleanup_pop(0); |
// I hope this task never reach this point... it is killed by J2!!! |
number--; |
mutex_unlock(&m0); |
cprintf("J3: unlocked m0, end task\n"); |
return 0; |
} |
void fine(KEY_EVT *e) |
{ |
sys_end(); |
} |
int main(int argc, char **argv) |
{ |
// struct timespec t; |
NRT_TASK_MODEL m; |
PI_mutexattr_t a; |
KEY_EVT emerg; |
//keyb_set_map(itaMap); |
emerg.ascii = 'x'; |
emerg.scan = KEY_X; |
emerg.flag = ALTL_BIT; |
keyb_hook(emerg,fine); |
/* --------------------------------------------------------------------- |
Task creation |
--------------------------------------------------------------------- */ |
nrt_task_default_model(m); |
nrt_task_def_group(m,1); |
p0 = task_create("J0", j0, &m, NULL); |
if (p0 == NIL) |
{ cprintf("Can't create J0 task...\n"); return 1; } |
p1 = task_create("J1", j1, &m, NULL); |
if (p1 == NIL) |
{ cprintf("Can't create J1 task...\n"); return 1; } |
p2 = task_create("J2", j2, &m, NULL); |
if (p2 == NIL) |
{ cprintf("Can't create J2 task...\n"); return 1; } |
p3 = task_create("J3", j3, &m, NULL); |
if (p3 == NIL) |
{ cprintf("Can't create J3 task...\n"); return 1; } |
/* --------------------------------------------------------------------- |
Mutex creation |
--------------------------------------------------------------------- */ |
PI_mutexattr_default(a); |
mutex_init(&m0,&a); |
cond_init(&c0); |
/* --------------------------------------------------------------------- |
Event post |
--------------------------------------------------------------------- */ |
group_activate(1); |
cprintf("END main\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/keycode.c |
---|
0,0 → 1,80 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, 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 |
* |
* |
* CVS : $Id: keycode.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
*/ |
#include <kernel/kern.h> |
#include <drivers/keyb.h> |
int main(int argc, char **argv) |
{ |
KEY_EVT k; |
clear(); |
k.ascii = 0; |
cprintf("Press ESC to end the demo, 2 for itamap, 3 for engmap\n"); |
while (k.ascii != ESC) { |
keyb_getcode(&k,BLOCK); |
if (k.ascii == '2') { |
keyb_set_map(itaMap); |
cprintf("\nItalian Keymap set\n"); |
} |
if (k.ascii == '3') { |
keyb_set_map(engMap); |
cprintf("\nEnglish Keymap set\n"); |
} |
if (isLeftCtrl(k)) putc_xy(72+0,0,RED,'L'); |
else putc_xy(72+0,0,RED,' '); |
if (isRightCtrl(k)) putc_xy(72+1,0,RED,'R'); |
else putc_xy(72+1,0,RED,' '); |
if (isLeftAlt(k)) putc_xy(72+2,0,GREEN,'L'); |
else putc_xy(72+2,0,RED,' '); |
if (isRightAlt(k)) putc_xy(72+3,0,GREEN,'R'); |
else putc_xy(72+3,0,RED,' '); |
if (isLeftShift(k)) putc_xy(72+4,0,YELLOW,'L'); |
else putc_xy(72+4,0,RED,' '); |
if (isRightShift(k)) putc_xy(72+5,0,YELLOW,'R'); |
else putc_xy(72+5,0,RED,' '); |
cprintf("%d [%c]\t",k.scan,k.ascii); |
} |
sys_end(); |
return 0; |
} |
/demos/tags/rel_0_2/base/mousfind.c |
---|
0,0 → 1,216 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, 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 |
* |
* |
* CVS : $Id: mousfind.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
*/ |
/* |
* Copyright (C) 2000 Paolo Gai, Massimiliano Giorgi |
* |
* 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/mouse.h> |
#include <drivers/keyb.h> |
/* don't include this into real applications!!! */ |
#include <../drivers/char/_mouse.h> |
int done; |
void my_mouse_hook(MOUSE_EVT *m) |
{ |
static int buttons=-1; |
if (buttons!=m->buttons) { |
buttons=m->buttons; |
//mouse_off(); |
if (isLeftButton(*m)) puts_xy(9,22,RED,"active"); |
else puts_xy(9,22,RED," "); |
if (isCentralButton(*m)) puts_xy(9,23,RED,"active"); |
else puts_xy(9,23,RED," "); |
if (isRightButton(*m)) puts_xy(9,24,RED,"active"); |
else puts_xy(9,24,RED," "); |
//mouse_on(); |
} |
/* |
if (tindex>20&&first) { |
int i; |
cprintf("\nSTART\n"); |
for (i=0;i<tindex;i++) { |
cprintf("%i\n",(int)tdata[i]); |
} |
for (i=1;i<tindex;i++) { |
cprintf("%i ",(int)(tdata[i]-tdata[i-1])); |
} |
first=0; |
} |
*/ |
} |
int main(int argc,char *argv[]) |
{ |
MOUSE_PARMS mouse=BASE_MOUSE; |
int ch,running,nm; |
int sens=5; |
/* screen */ |
clear(); |
nm=0; |
while (*vmouse[nm].name!='\0') { |
cprintf("%c %s:\t %s\n",(char)('a'+nm),vmouse[nm].name,vmouse[nm].desc); |
nm++; |
} |
cprintf("\n[a-%c]\t select a mouse server\n",(char)(nm+'a'-1)); |
cprintf("[z]\t decrement mouse threshold\n"); |
cprintf("[x]\t incremnet mouse threshold\n"); |
cprintf("[1-4]\t COM port\n"); |
cprintf("[ENTER]\t exit\n"); |
place(0,20); |
cputs("mouse server:\n"); |
cputs("threshold:\n"); |
cputs("left :\n"); |
cputs("central:\n"); |
cputs("right :"); |
CRSR_OFF(); |
/* main loop */ |
running=done=0; |
mouse_def_ms(mouse,0); |
while (!done) { |
ch=keyb_getch(TRUE); |
switch(ch) { |
/* exit demo */ |
case ENTER: |
done = 1; |
break; |
/* decrement threshold */ |
case 'z': |
sens--; |
if (sens<2) sens=2; |
mouse_threshold(sens); |
/* threshold */ |
place(11,21); |
cprintf("%i ",sens); |
break; |
/* increment threshold */ |
case 'x': |
sens++; |
if (sens>100) sens=100; |
mouse_threshold(sens); |
/* threshold */ |
place(11,21); |
cprintf("%i ",sens); |
break; |
/* change mouse protocol */ |
default: |
if (ch>='a'&&ch<='a'+nm-1) { |
/* don't use this method to change a mouse protocol */ |
/* use mouse_def_???? macros instead */ |
mouse.type=ch-'a'; |
} else |
if (ch>='1'&&ch<='4') { |
/* don't use this method to change a mouse com port */ |
/* use mouse_def_???? macros instead */ |
mouse.port = ch-'1'; |
} |
else |
break; |
/* check if a mouse server is running... */ |
if (running) { |
/* disable autocursor */ |
mouse_txtcursor(DISABLE); |
/* destroy actual mouse server */ |
mouse_end(); |
} |
/* mouse server name */ |
puts_xy(14,20,GREEN," "); |
puts_xy(14,20,GREEN,vmouse[mouse.type].name); |
/* threshold */ |
place(11,21); |
cprintf("%i ",sens); |
/* start a new server */ |
running=(mouse_init(&mouse)==0?1:0); |
/* if running ...*/ |
if (running) { |
/* set mouse limit */ |
mouse_limit(0,0,cons_columns-1,cons_rows-1); |
/* enable autocursor */ |
mouse_txtcursor(ENABLE|AUTOOFF); |
/* hook my function */ |
mouse_hook(my_mouse_hook); |
/* show mouse cursor */ |
mouse_on(); |
} |
break; |
} |
} |
CRSR_STD(); |
clear(); |
sys_end(); |
return 0; |
} |
/demos/tags/rel_0_2/base/semdemo.c |
---|
0,0 → 1,97 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: semdemo.c,v 1.1 2002-11-11 08:22:46 pj Exp $ |
This is a really simple semaphore demo. |
*/ |
#include "kernel/kern.h" |
#include "semaphore.h" |
sem_t s; |
void *goofy(void *a) |
{ |
struct timespec t; |
char *n = proc_table[exec_shadow].name; |
cprintf("Task %s: Locking semaphore...\n", n); |
sem_wait(&s); |
cprintf("Task %s: Semaphore locked...\n", n); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < (int)a); |
cprintf("Task %s: Unlocking semaphore...\n", n); |
sem_post(&s); |
cprintf("Task %s: Semaphore unlocked...\n", n); |
return 0; |
} |
int main(int argc, char **argv) |
{ |
NRT_TASK_MODEL m; |
PID p2,p3; |
nrt_task_default_model(m); |
nrt_task_def_group(m,1); |
nrt_task_def_arg(m,(void *)1); |
p2 = task_create("goofy1", goofy, &m, NULL); |
if (p2 == NIL) |
{ cprintf("Can't create goofy1 task...\n"); return 1; } |
nrt_task_def_arg(m,(void *)2); |
p3 = task_create("goofy2", goofy, &m, NULL); |
if (p3 == NIL) |
{ cprintf("Can't create goofy2 task...\n"); return 1; } |
cprintf("Initializing semaphore...\n"); |
sem_init(&s,0,1); |
group_activate(1); |
return 0; |
} |
/demos/tags/rel_0_2/base/talk.c |
---|
0,0 → 1,209 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Luca Abeni, 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 |
* |
* |
* CVS : $Id: aster1.c,v 1.1 2002/10/28 08:13:37 pj Exp |
This is the talkdx.c Hartik's example. |
File: Talk.C |
Revision: 1.00 |
Author: Luca Abeni |
Simple Netlib demo: nothing of seriously real-time, only another Unix |
Talk clone. |
Read it to see how the UDP/IP layers of the networ library work. |
*/ |
#include <kernel/kern.h> |
#include <string.h> |
#include <drivers/crtwin.h> |
#include <drivers/keyb.h> |
#include <drivers/udpip.h> |
WIN dbg; |
BYTE esc = FALSE; |
char talk_myipaddr[20]; |
char talk_toipaddr[20]; |
/* |
This non real-time task reads UDP packets from the network and writes |
them in a window |
*/ |
TASK scrittore(void) |
{ |
char str[2000]; |
UDP_ADDR from, local; |
WIN displ; |
int s,n; |
/* Connect on the local port #100 */ |
local.s_port = 100; |
s = udp_bind(&local, NULL); |
/* Open the window */ |
win_init(&displ,0,0,79,6); |
win_frame(&displ,BLACK,WHITE,"Remote",2); |
while (1) { |
/* Clear the buffer for receiving the packet...*/ |
memset(str, 0, 1999); |
/*...and receive the packet (block until a packet arrives */ |
n = udp_recvfrom(s, str, &from); |
win_puts(&displ, str); |
} |
} |
/* |
This non real-time task reads strings from the keyoard and sends them |
to the remote host |
*/ |
TASK write(void) |
{ |
WIN wr; |
UDP_ADDR to,local; |
char str[80]; |
int s; |
IP_ADDR bindlist[5]; |
/* Create a socket for transitting */ |
ip_str2addr(talk_myipaddr,&(local.s_addr)); |
local.s_port = 101; |
/* |
If we want the address of the remote host in the ARP table before |
begginning the transmission (to eliminate a possible source of |
unpredictability), we can use the bindlist, otherwise we set the |
second parameter of udp_bind to NULL |
*/ |
ip_str2addr(talk_toipaddr,&(bindlist[0])); |
memset(&(bindlist[1]), 0, sizeof(IP_ADDR)); |
s = udp_bind(&local, /*bindlist*/NULL); |
win_init(&wr,0,7,79,6); |
win_frame(&wr,BLACK,WHITE,"Local",2); |
ip_str2addr(talk_toipaddr,&(to.s_addr)); |
to.s_port = 100; |
sprintf(str,"Local IP address %d.%d.%d.%d\n", local.s_addr.ad[0], |
local.s_addr.ad[1], local.s_addr.ad[2], |
local.s_addr.ad[3]); |
win_puts(&dbg,str); |
sprintf(str,"Talk to %d.%d.%d.%d ",to.s_addr.ad[0],to.s_addr.ad[1], |
to.s_addr.ad[2],to.s_addr.ad[3]); |
win_puts(&dbg,str); |
while (1) { |
/* Get the string...*/ |
win_gets(&wr,str,78); |
strcat(str,"\n"); |
/*...and send it!!! */ |
udp_sendto(s,str,strlen(str)+2,&to); |
} |
} |
/* This function is called when the user presses CTRL-C (stops the systems) */ |
void esci(KEY_EVT *k) |
{ |
esc = TRUE; |
cprintf("Ctrl-Brk pressed!\n"); |
sys_end(); |
} |
int main(int argc, char **argv) |
{ |
KEY_EVT k; |
struct net_model m = net_base; |
NRT_TASK_MODEL m_nrt; |
k.flag = CNTL_BIT; |
k.scan = KEY_C; |
k.ascii = 'c'; |
keyb_hook(k,esci); |
k.flag = CNTR_BIT; |
k.scan = KEY_C; |
k.ascii = 'c'; |
keyb_hook(k,esci); |
clear(); |
cprintf(" Hartik Talk! Ver. 1.00\n"); |
if (argc != 3) { |
cprintf("Hartik Talk usage: talk fromIP toIP\n"); |
return 0; |
} |
strcpy(talk_myipaddr, argv[1]); |
strcpy(talk_toipaddr, argv[2]); |
/* We want a task for TX mutual exclusion */ |
net_setmode(m, TXTASK); |
/* We use UDP/IP stack */ |
net_setudpip(m, talk_myipaddr); |
/* OK: let's start the NetLib! */ |
if (net_init(&m) == 1) { |
cprintf("Net Init OK...\n"); |
} else { |
cprintf("Net Init Failed...\n"); |
sys_abort(300); |
} |
//dump_irq(); |
cprintf("\n\n\n\tPress ENTER\n"); |
while (!esc) { |
keyb_getcode(&k,BLOCK); |
if (k.ascii == 13) esc = TRUE; |
} |
esc = FALSE; |
clear(); |
win_init(&dbg,0,20,60,3); |
win_frame(&dbg,BLACK,WHITE,"Debug",2); |
/* Start the sender and receiver tasks...*/ |
nrt_task_default_model(m_nrt); |
task_activate(task_create("aaa",scrittore,&m_nrt,NULL)); |
task_activate(task_create("bbb",write,&m_nrt,NULL)); |
return 0; |
} |
/demos/tags/rel_0_2/base/aster2.c |
---|
0,0 → 1,241 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: aster2.c,v 1.2 2002-11-11 08:20:44 pj Exp $ |
this is a part of the classic Hartik demo Aster. |
It checks: |
- jet functions |
- The EDF level with many task, with almost full bandwidth used |
*/ |
#include "kernel/kern.h" |
#include "modules//edf.h" |
int num_aster = 0; |
#define ASTER_LIM 60 |
#define DISPLAY_MAX 15 |
#define ASTER_MAX 70 |
#define STAT_Y 9 |
// first numbers for wcet and periods are for a 486/25, the others for a |
// celeron 366 |
#define PER_WCET 13000 /*6200*/ |
#define CLOCK_WCET 1200 /* 100*/ |
#define ASTER_WCET 1200 /* 100*/ |
#define ASTER_MEAN_PERIOD 64 /*64*/ |
#define END_TEST_TIME 60 |
TASK asteroide(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
/*for (;;)*/ { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 1000; //10000; // 5000 + rand()%5000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
} |
num_aster--; |
return 0; |
} |
TASK aster() |
{ |
PID p; |
HARD_TASK_MODEL m; |
int r; |
int x; // adaptive bandwidth... |
hard_task_default_model(m); |
hard_task_def_wcet(m,PER_WCET); |
hard_task_def_ctrl_jet(m); |
x = ASTER_MEAN_PERIOD; |
srand(7); |
while (1) { |
if (num_aster < ASTER_MAX) { |
r = (rand() % 200); |
hard_task_def_arg(m,(void *)((rand() % 7)+1)); |
hard_task_def_mit(m, (x+r)*1000); |
p = task_create("aaa",asteroide,&m,NULL); |
if (p == -1) |
{ |
if (x < 500 && errno != ENO_AVAIL_TASK) x += 1; |
printf_xy(62,3,WHITE,"adapt=%3u err=%d", |
iq_query_first(&freedesc),errno); |
} |
else { |
num_aster++; |
printf_xy(62,3,WHITE,"adapt=%3u ",x);//,errno); |
task_activate(p); |
x /= 2; |
if (x<50) x = 50; |
} |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0)); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0)); |
task_endcycle(); |
} |
} |
/* we consider the first ASTER_MAX + 2 tasks from the PID 2 |
and plot on the screen the elapsed times... */ |
TASK jetcontrol() |
{ |
int i; /* a counter */ |
TIME sum, max, curr, last[5]; |
int nact; |
int j; /* the elements set by jet_gettable */ |
PID p; |
kern_cli(); |
printf_xy(0,STAT_Y,WHITE,"PID ³ Mean T.³ Max T. ³ N.A. ³ Curr. ³ Last1 ³ Last2 ³ Last3 ³ Last4 ³ Last5"); |
kern_sti(); |
for (;;) { |
for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) { |
if (jet_getstat(p, &sum, &max, &nact, &curr) == -1) continue; |
for (j=0; j<5; j++) last[j] = 0; |
jet_gettable(p, &last[0], 5); |
kern_cli(); |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
kern_sti(); |
i++; |
} |
} |
} |
int main(int argc, char **argv) |
{ |
PID p1,p2,p3; //,p4,p5,p6; |
HARD_TASK_MODEL m; |
NRT_TASK_MODEL m_nrt; |
struct timespec t; |
clear(); |
hard_task_default_model(m); |
hard_task_def_wcet(m,ASTER_WCET); |
hard_task_def_mit(m,10000); |
hard_task_def_group(m,1); |
hard_task_def_ctrl_jet(m); |
nrt_task_default_model(m_nrt); |
nrt_task_def_group(m_nrt,1); |
nrt_task_def_ctrl_jet(m_nrt); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("test7.c(main): Could not create task <aster> ..."); |
sys_end(); |
} |
hard_task_def_mit(m,500000); |
hard_task_def_wcet(m,CLOCK_WCET); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <Clock> ..."); |
sys_end(); |
} |
p3 = task_create("JetControl",jetcontrol,&m_nrt,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <JetControl> ..."); |
sys_end(); |
} |
group_activate(1); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < END_TEST_TIME); |
sys_end(); |
return 0; |
} |
/demos/tags/rel_0_2/base/aster3.c |
---|
0,0 → 1,302 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: aster3.c,v 1.2 2002-11-11 08:20:44 pj Exp $ |
Test Number 10 (A): |
this is a part of the classic Hartik demo Aster. |
it is based on aster2.c, with the use of TBS to serve a set of aperiodic |
tasks. |
There are APER_MAX tasks sleeping, and when an asteroide task finish |
the current activation, it activate also an aperiodic task chosen |
randomly (if the task chosen is already active, the task_activate do |
nothing!) |
*/ |
#include "kernel/kern.h" |
#include "modules//edf.h" |
int num_aster = 0; |
#define ASTER_LIM 60 |
#define DISPLAY_MAX 15 |
#define ASTER_MAX 70 |
#define STAT_Y 9 |
#define APER_MAX 8 |
/* first numbers runs on a pentium 133, second numbers on a celeron 366 */ |
#define PER_WCET 30000 /* 6200 */ |
#define APER_WCET 50000 /* 18400 */ |
#define CLOCK_WCET 1000 /* 200 */ |
#define ASTER_WCET 1000 /* 200 */ |
#define MIN_PERIOD 200 /* 64, in ms */ |
#define APER_REP 22000 |
PID aper_table[APER_MAX]; |
TASK asteroide(void) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
char s[2]; |
s[0] = '*'; s[1] = 0; |
/*for (;;)*/ { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = 10000; //8000 + rand()%2000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
task_activate(aper_table[rand()%APER_MAX]); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
} |
num_aster--; |
return 0; |
} |
TASK aper_asteroid(void *a) |
{ |
int i; |
int y = rand() % 7 + 1; |
int load1,j; |
int c; |
char s[2]; |
c = (int)a; |
s[0] = '*'; s[1] = 0; |
for (;;) { |
i = 1; |
while (i < ASTER_LIM) { |
load1 = APER_REP; //8000 + rand()%2000; |
for (j=0; j<load1; j++) { |
s[0] = '*' + rand() % 100; |
puts_xy(i,y,rand()%15+1,s); |
} |
s[0] = c; |
puts_xy(i,y,rand()%15+1,s); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
} |
} |
TASK aster() |
{ |
PID p; |
HARD_TASK_MODEL m; |
int r; |
int x; // adaptive bandwidth... |
hard_task_default_model(m); |
hard_task_def_wcet(m,PER_WCET); |
hard_task_def_ctrl_jet(m); |
x = MIN_PERIOD; |
srand(7); |
while (1) { |
if (num_aster < ASTER_MAX) { |
r = (rand() % 200); |
hard_task_def_arg(m,(void *)((rand() % 7)+1)); |
hard_task_def_mit(m, (x+r)*1000); |
p = task_create("aaa",asteroide,&m,NULL); |
if (p == -1) |
{ |
if (x < 500 && errno != ENO_AVAIL_TASK) x += 1; |
printf_xy(62,3,WHITE,"adapt=%3u err=%d", |
iq_query_first(&freedesc),errno); |
} |
else { |
num_aster++; |
printf_xy(62,3,WHITE,"adapt=%3u ",x);//,errno); |
task_activate(p); |
x /= 2; |
if (x<50) x = 50; |
} |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0)); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
printf_xy(62,1,WHITE,"%2d:%2d ast=%d",m,s, num_aster); |
printf_xy(62,2,WHITE,"U=%12u",EDF_usedbandwidth(0)); |
task_endcycle(); |
} |
} |
/* we consider the first ASTER_MAX + 2 tasks from the PID 2 |
and plot on the screen the elapsed times... */ |
TASK jetcontrol() |
{ |
int i; /* a counter */ |
TIME sum, max, curr, last[5]; |
int nact; |
int j; /* the elements set by jet_gettable */ |
PID p; |
kern_cli(); |
printf_xy(0,STAT_Y,WHITE,"PID ³ Mean T.³ Max T. ³ N.A. ³ Curr. ³ Last1 ³ Last2 ³ Last3 ³ Last4 ³ Last5"); |
kern_sti(); |
for (;;) { |
for (i=0,p=0; i<DISPLAY_MAX+5 && p<MAX_PROC; p++) { |
if (jet_getstat(p, &sum, &max, &nact, &curr) == -1) continue; |
for (j=0; j<5; j++) last[j] = 0; |
jet_gettable(p, &last[0], 5); |
kern_cli(); |
printf_xy(0,STAT_Y+i+1,WHITE,"%-3d ³ %-6d ³ %-6d ³ %-4d ³ %-7d ³ %-5d ³ %-5d ³ %-5d ³ %-5d ³ %-5d", |
p, (int)sum/(nact==0 ? 1 : nact), (int)max, (int)nact, (int)curr, (int)last[0], (int)last[1], (int)last[2], (int)last[3], (int)last[4]); |
kern_sti(); |
i++; |
} |
task_endcycle(); |
} |
} |
int main(int argc, char **argv) |
{ |
PID p1,p2;//,p3,p4,p5,p6; |
HARD_TASK_MODEL m; |
NRT_TASK_MODEL m_nrt; |
SOFT_TASK_MODEL m_aper; |
int i; |
clear(); |
set_exchandler_grx(); |
hard_task_default_model(m); |
hard_task_def_wcet(m,ASTER_WCET); |
hard_task_def_mit(m,10000); |
hard_task_def_group(m,1); |
hard_task_def_ctrl_jet(m); |
nrt_task_default_model(m_nrt); |
nrt_task_def_group(m_nrt,1); |
nrt_task_def_ctrl_jet(m_nrt); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("test7.c(main): Could not create task <aster> ..."); |
sys_end(); |
} |
hard_task_def_mit(m,500000); |
hard_task_def_wcet(m,CLOCK_WCET); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("test7.c(main): Could not create task <Clock> ..."); |
sys_end(); |
} |
soft_task_default_model(m_aper); |
soft_task_def_wcet(m_aper,APER_WCET); |
soft_task_def_ctrl_jet(m_aper); |
soft_task_def_aperiodic(m_aper); |
soft_task_def_level(m_aper, 2); |
aper_table[0] = task_create("JetControl",jetcontrol,&m_aper,NULL); |
if (aper_table[0] == -1) { |
perror("test7.c(main): Could not create task <JetControl> ..."); |
sys_end(); |
} |
for (i=1; i<APER_MAX; i++) { |
soft_task_def_level(m_aper, i/4 + 2); |
soft_task_def_arg(m_aper, (void *)(i/4 ? 'Û' : '±')); |
aper_table[i] = task_create("aper",aper_asteroid,&m_aper,NULL); |
if (aper_table[i] == -1) { |
perror("test7.c(main): Could not create task <aper> ..."); |
sys_end(); |
} |
} |
group_activate(1); |
{ |
struct timespec t; |
do { |
sys_gettime(&t); |
} while (t.tv_sec < 60); |
} |
sys_end(); |
return 0; |
} |
/demos/tags/rel_0_2/base/readme |
---|
0,0 → 1,50 |
This directory contains a set of simple examples, useful to understand |
How to make a Shark application. |
Text mode demos: |
- hello.c --> a hello world application |
- timer.c --> tests if the time reads are always increasing |
(useful for debugging purposes) |
- sig.c --> simple example that sends signals |
- semdemo.c --> simple example that uses a semaphore for mutual exclusion |
- pidemo.c --> simple example that uses PI mutexes between NRT and Hard tasks |
- pcdemo.c --> simple example that uses PC mutexes between NRT and Hard tasks |
- srpdemo.c --> simple example that uses SRP mutexes between NRT and Hard tasks |
- mdemo.c --> simple example that uses a mutex, initialized with whatever |
protocol you want ;-) |
- aster.c --> Wow! the original Hartik ASTER demo!!! (EDF, CABs, ...) |
- aster1.c --> a -lot- of periodic tasks that are created and then die |
(6 seconds demo) |
- aster2.c --> a simple stress test: a lot of tasks are created until Utot=1; |
uses jet functions to dump statistics. (60 seconds demo) |
- aster3.c --> aster2 + 8 tasks handled by 2 different TBS servers |
- aster4.c --> aster3 + CBS tasks + Shutdown demo with system tasks |
- aster5.c --> aster3 + only CBS tasks + mutexes... Really interesting! |
- aster6.c --> aster5 + Polling Server to serve the JetCtrl task |
- aster7.c --> another aster clone with Rate monotonic and Polling server |
- aster8.c --> aster5 + Sporadic Server |
- preempt.c --> simple test for CBS, task_preempt, task_nopreempt, and |
save/skip arrivals |
- pcidemo.c --> PCI Bus scan |
- talk.c --> UDP Unix Talk clone (useful to understand the network driver) |
- mousfind.c--> Simple text mouse protocol finder |
- jointest.c--> Simple test that uses the task_join primitive |
- condtest.c--> Simple test that uses condition variables |
- intsem.c --> Simple test that uses internal semaphores |
- keycode.c --> Prints Keyboard Keycodes on the screen |
- memtest.c --> Do you need to use malloc, kern_alloc & co? |
Graphical demos: |
- fly.c --> Random flies going around the screen |
- ego.c --> Periodic tasks that writes a phrease on the screen |
- cabs.c --> Example that uses cabs |
- sched.c --> Scheduling example (mouse, EDF, RM, DS, PS, TBS) |
Note on the init files: |
- ihello.c (RR+dummy) |
- isemdemo.c (iaster1+Semaphores) |
- iaster1.c (EDF+RR+dummy) |
- iaster3.c (EDF+RR+TBS(0.1)+TBS(0.3)+dummy) |
- iaster4.c (iaster3+CBS) |
- initfile.c (EDF+CBS+RR+dummy, SEMaphores, CABS, HARTPORTs and Keyboard) |
- isched.c (Configurable scheduling architecture) |
/demos/tags/rel_0_2/base/sig.c |
---|
0,0 → 1,163 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: sig.c,v 1.2 2002-11-11 08:20:44 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.2 $ |
Last update: $Date: 2002-11-11 08:20:44 $ |
------------ |
**/ |
/* |
* Copyright (C) 2000 Paolo Gai and Giorgio Buttazzo |
* |
* 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 |
* |
*/ |
/* |
Test Number 5: |
this test is a simple main() function with one other task |
This test can be useful to test functions like: |
sys_gettime |
sigemptyset |
sigaddset |
hartik_deliver_pending_signals |
sys_end |
task_sigmask |
sigaction |
sigqueue |
task_signal |
*/ |
#include "kernel/kern.h" |
TASK goofy(void *arg) |
{ |
struct timespec t; |
cprintf("Goofy: waiting 2 secs...\n"); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < 2); // wait until 2 sec |
cprintf("Goofy: ok, I'm ready :-)\n"); |
return 0; |
} |
void catchit(int signo, siginfo_t *info, void *extra) |
{ |
cprintf("Current Running Task = %d signo=%d code=%d value=%d from pid=%d\n", |
exec_shadow, |
info->si_signo, info->si_code, |
info->si_value.sival_int, info->si_task); |
} |
int main(int argc, char **argv) |
{ |
struct timespec t; |
NRT_TASK_MODEL m; |
PID p2; |
sigset_t newmask; |
sigset_t oldmask; |
struct sigaction action; |
union sigval sval; |
clear(); |
/* Set the signal action */ |
action.sa_flags = SA_SIGINFO; |
action.sa_sigaction = catchit; |
action.sa_handler = 0; |
action.sa_mask = 0; |
if (sigaction(SIGUSR1, &action, NULL) == -1) { |
perror("Error using sigaction."); |
return -1; |
} |
action.sa_flags = 0; |
action.sa_handler = (void (*)(int))catchit; |
if (sigaction(SIGILL, &action, NULL) == -1) { |
perror("Error using sigaction."); |
return -1; |
} |
/* create another task */ |
nrt_task_default_model(m); |
nrt_task_def_group(m,1); |
p2 = task_create("goofy", goofy, &m, NULL); |
if (p2 == NIL) |
{ |
cprintf("Can't create goofy task...\n"); |
return 1; |
} |
group_activate(1); |
/* block the signal for the main task */ |
sigemptyset(&newmask); |
sigaddset(&newmask,SIGUSR1); |
task_sigmask(SIG_BLOCK, &newmask, &oldmask); // pthread_sigmask |
cprintf("main: Sending 2 signals ...\n"); |
sval.sival_int = 123; |
sigqueue(0,SIGUSR1,sval); |
sval.sival_int = 999; |
sigqueue(0,SIGUSR1,sval); |
cprintf("main: Now sending a signal to myself," |
" then wait until 4 secs...\n"); |
task_signal(0 /* main */, SIGILL); // pthread_kill |
NULL_TIMESPEC(&t); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < 4); // wait until 4 s |
cprintf("main: ending...\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/makefile |
---|
7,10 → 7,96 |
endif |
include $(BASE)/config/config.mk |
PROGS= ego fly cabs |
PROGS = hello sig time preempt |
PROGS += aster aster1 aster2 aster3 aster4 aster5 aster6 aster7 aster8 |
PROGS += pcidemo talk mousfind keycode memtest |
PROGS += jointest condtest intsem semdemo pidemo pcdemo srpdemo mdemo |
PROGS += ego fly cabs sched |
include $(BASE)/config/example.mk |
# Text applications |
hello: |
make -f $(SUBMAKE) APP=hello INIT= OTHEROBJS="ihello.o" OTHERINCL= |
time: |
make -f $(SUBMAKE) APP=time INIT= OTHEROBJS="ihello.o" OTHERINCL= |
sig: |
make -f $(SUBMAKE) APP=sig INIT= OTHEROBJS="ihello.o" OTHERINCL= |
preempt: |
make -f $(SUBMAKE) APP=preempt INIT= OTHEROBJS="initfile.o" OTHERINCL= |
semdemo: |
make -f $(SUBMAKE) APP=semdemo INIT= OTHEROBJS="isemdemo.o" OTHERINCL= |
pidemo: |
make -f $(SUBMAKE) APP=pidemo INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
pcdemo: |
make -f $(SUBMAKE) APP=pcdemo INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
srpdemo: |
make -f $(SUBMAKE) APP=srpdemo INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
mdemo: |
make -f $(SUBMAKE) APP=mdemo INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
aster: |
make -f $(SUBMAKE) APP=aster INIT= OTHEROBJS="initfile.o" OTHERINCL= |
aster1: |
make -f $(SUBMAKE) APP=aster1 INIT= OTHEROBJS="iaster1.o" OTHERINCL= |
aster2: |
make -f $(SUBMAKE) APP=aster2 INIT= OTHEROBJS="iaster1.o" OTHERINCL= |
aster3: |
make -f $(SUBMAKE) APP=aster3 INIT= OTHEROBJS="iaster3.o" OTHERINCL= |
aster4: |
make -f $(SUBMAKE) APP=aster4 INIT= OTHEROBJS="iaster4.o" OTHERINCL= |
aster5: |
make -f $(SUBMAKE) APP=aster5 INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
aster6: |
make -f $(SUBMAKE) APP=aster6 INIT= OTHEROBJS="iaster6.o" OTHERINCL= |
aster7: |
make -f $(SUBMAKE) APP=aster7 INIT= OTHEROBJS="iaster7.o" OTHERINCL= |
aster8: |
make -f $(SUBMAKE) APP=aster8 INIT= OTHEROBJS="iaster8.o" OTHERINCL= |
pcidemo: |
make -f $(SUBMAKE) APP=pcidemo INIT= OTHEROBJS="initfile.o" OTHERINCL= |
talk: |
make -f $(SUBMAKE) APP=talk INIT= OTHEROBJS="initfile.o" OTHERINCL= |
mousfind: |
make -f $(SUBMAKE) APP=mousfind INIT= OTHEROBJS="initfile.o" OTHERINCL= |
jointest: |
make -f $(SUBMAKE) APP=jointest INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
condtest: |
make -f $(SUBMAKE) APP=condtest INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
intsem: |
make -f $(SUBMAKE) APP=intsem INIT= OTHEROBJS="imdemo.o" OTHERINCL= |
keycode: |
make -f $(SUBMAKE) APP=keycode INIT= OTHEROBJS="initfile.o" OTHERINCL= |
memtest: |
make -f $(SUBMAKE) APP=memtest INIT= OTHEROBJS="initfile.o" OTHERINCL= |
# Graphical applications |
ego: |
make -f $(SUBMAKE) APP=ego INIT= OTHEROBJS="initfile.o" OTHERINCL= |
20,3 → 106,5 |
cabs: |
make -f $(SUBMAKE) APP=cabs INIT= OTHEROBJS="initfile.o" OTHERINCL= |
sched: |
make -f $(SUBMAKE) APP=sched INIT= OTHEROBJS="isched.o" OTHERINCL= |
/demos/tags/rel_0_2/base/time.c |
---|
0,0 → 1,69 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: time.c,v 1.1 2002-10-28 08:13:37 pj Exp $ |
* |
* Timer correctness test |
*/ |
#include "kernel/kern.h" |
#define NT 10 |
int main(int argc, char **argv) |
{ |
struct timespec t[NT]; |
int i; |
cprintf("Timer correctness test (1 second).\n"); |
for (i=0; i<NT; i++) NULL_TIMESPEC(&t[i]); |
do { |
for (i=0; i<NT-1; i++) t[i+1] = t[i]; |
sys_gettime(&t[0]); |
if (TIMESPEC_A_LT_B(&t[0],&t[1])) { |
for (i=0; i<NT; i++) |
cprintf("%d %ld\n",i, t[i].tv_nsec); |
sys_end(); |
} |
} while (t[0].tv_sec < 1); |
return 0; |
} |
/demos/tags/rel_0_2/base/aster1.c |
---|
0,0 → 1,175 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
* |
* |
* CVS : $Id: aster1.c,v 1.1 2002-10-28 08:13:37 pj Exp $ |
this is a reduced verion of the classic Hartik demo Aster. |
It uses: |
- EDF module |
. periodic tasks |
- an high number of task executing concurrently |
The demo ends after 6 seconds. |
*/ |
/* |
Well, this is only a stupid demo which intend to show many |
HARTIK+ capabilities; the application is structured in the followig |
way: there is an ASTER task wich randomly creates some ASTEROID tasks |
which are displayed into the first window; each task is HARD/PERIODIC |
and auto-kills itself when it reaches the window end! |
Finally a CLOCK task is implemented to test system clock. |
Please note that usually the HARTIK+ application is made up of a task |
group which interacts among them, while the main() function, which |
became a task itself when the kernel is activated, is suspended until |
the system is ready to terminate; the MAIN task can also be used to make |
other background activities, but it should not be killed; when the |
application terminates, the control is passed to MAIN which kills |
everybody, shut down the system and can handle other operations using |
the services available with the previou operating system (I.E. the DOS). |
If you need to manage sudden abort/exception you should install your own |
exception handler and raise it through the exc_raise() primitive to |
make the system abort safely! |
Remember that the exit functions posted through sys_atexit() will be |
executed in both cases, to allow clean system shutdown. |
*/ |
#include "kernel/kern.h" |
int num_aster = 0; |
#define ASTER_LIM 67 |
#define ASTER_MAX 90 |
TASK asteroide(void) |
{ |
int i = 1; |
int y = rand() % 20 + 1; |
while (i < ASTER_LIM) { |
puts_xy(i,y,WHITE,"*"); |
task_endcycle(); |
puts_xy(i,y,WHITE," "); |
i++; |
} |
num_aster--; |
return 0; |
} |
DWORD taskCreated = 0; |
TASK aster(void) |
{ |
PID p; |
HARD_TASK_MODEL m; |
int r; |
hard_task_default_model(m); |
hard_task_def_wcet(m,500); |
srand(7); |
while (1) { |
if (num_aster < ASTER_MAX) { |
r = (rand() % 50) - 25; |
hard_task_def_arg(m,(void *)((rand() % 7)+1)); |
hard_task_def_mit(m, (50+r)*1000); |
p = task_create("aaa",asteroide,&m,NULL); |
taskCreated++; |
task_activate(p); |
num_aster++; |
} |
task_endcycle(); |
} |
} |
TASK clock() |
{ |
int s = 0, m = 0; |
while(1) { |
printf_xy(70,1,WHITE,"%2d : %2d",m,s); |
task_endcycle(); |
if (++s > 59) { |
s = 0; |
m++; |
} |
printf_xy(70,1,WHITE,"%2d : %2d",m,s); |
task_endcycle(); |
} |
} |
int main(int argc, char **argv) |
{ |
PID p1,p2; |
HARD_TASK_MODEL m; |
struct timespec t; |
clear(); |
hard_task_default_model(m); |
hard_task_def_mit(m,10000); |
hard_task_def_wcet(m,2000); |
hard_task_def_group(m,1); |
p1 = task_create("Aster",aster,&m,NULL); |
if (p1 == -1) { |
perror("Aster.C(main): Could not create task <aster> ..."); |
sys_end(); |
} |
hard_task_def_mit(m,500000); |
p2 = task_create("Clock",clock,&m,NULL); |
if (p2 == -1) { |
perror("Aster.C(main): Could not create task <Clock> ..."); |
sys_end(); |
} |
group_activate(1); |
do { |
sys_gettime(&t); |
} while (t.tv_sec < 6); |
sys_status(SCHED_STATUS); |
sys_end(); |
return 0; |
} |
/demos/tags/rel_0_2/base/hello.c |
---|
0,0 → 1,53 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* 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 |
*/ |
/* |
CVS : $Id: hello.c,v 1.1 2002-10-28 08:13:37 pj Exp $ |
hello.c: |
This test is a simple hello world function. |
*/ |
#include "kernel/kern.h" |
int main(int argc, char **argv) |
{ |
cprintf("Hello, world!\n"); |
return 0; |
} |
/demos/tags/rel_0_2/base/iaster1.c |
---|
0,0 → 1,99 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: iaster1.c,v 1.1 2002-10-28 08:13:37 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-10-28 08:13:37 $ |
------------ |
System initialization file |
The tick is set to TICK ms. |
This file contains the 2 functions needed to initialize the system. |
These functions register the following levels: |
an EDF (Earliest Deadline First) level |
a RR (Round Robin) level |
a Dummy level |
It can accept these task models (into () the mandatory fields): |
HARD_TASK_MODEL (wcet+mit) at level 0 |
NRT_TASK_MODEL at level 1 |
**/ |
/* |
* 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 "modules/edf.h" |
#include "modules/rr.h" |
#include "modules/dummy.h" |
/*+ sysyem tick in us +*/ |
#define TICK 10000 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
dummy_register_level(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/iaster3.c |
---|
0,0 → 1,111 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: iaster3.c,v 1.1 2002-10-28 08:13:37 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-10-28 08:13:37 $ |
------------ |
System initialization file |
The tick is set to TICK ms. |
This file contains the 2 functions needed to initialize the system. |
These functions register the following levels: |
an EDF (Earliest Deadline First) level |
a RR (Round Robin) level |
a TBS (Total Bandwidth Server) level 0.1 Us |
a TBS (Total Bandwidth Server) level 0.3 Us |
a Dummy level |
The TBS bandwidth is TBS_NUM/TBS_DEN |
It can accept these task models (into () the mandatory fields): |
HARD_TASK_MODEL (wcet+mit) at level 0 |
NRT_TASK_MODEL at level 1 |
SOFT_TASK_MODEL (wcet, periodicity=APERIODIC) at level 2,3 |
**/ |
/* |
* 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 "modules/edf.h" |
#include "modules/rr.h" |
#include "modules/tbs.h" |
#include "modules/dummy.h" |
#include "drivers/keyb.h" |
/*+ sysyem tick in us +*/ |
#define TICK 1200 |
#define RRTICK 5000 |
#define TBS_NUM 1 |
#define TBS_DEN 10 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
TBS_register_level(TBS_ENABLE_ALL, 0, TBS_NUM, TBS_DEN); |
TBS_register_level(TBS_ENABLE_ALL, 0, TBS_NUM*3, TBS_DEN); |
dummy_register_level(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/ihello.c |
---|
0,0 → 1,95 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/** |
------------ |
CVS : $Id: ihello.c,v 1.1 2002-10-28 08:13:37 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1 $ |
Last update: $Date: 2002-10-28 08:13:37 $ |
------------ |
The simplest initialization file |
The tick is set to TICK ms. |
This file contains the 2 functions needed to initialize the system. |
These functions register the following levels: |
a RR (Round Robin) level |
a Dummy level |
It can accept these task models: |
NRT_TASK_MODEL at level 0 |
**/ |
/* |
* 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 "modules/rr.h" |
#include "modules/dummy.h" |
/*+ sysyem tick in us +*/ |
#define TICK 300 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
RR_register_level(RRTICK, RR_MAIN_YES, mb); |
dummy_register_level(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
__call_main__(mb); |
return (void *)0; |
} |
/demos/tags/rel_0_2/base/cabs.c |
---|
1,3 → 1,42 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Paolo Gai <pj@gandalf.sssup.it> |
* (see the web pages for full authors list) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://shark.sssup.it |
*/ |
/* |
* Copyright (C) 2000 Giorgio Buttazzo, 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 |
* |
* |
* CVS : $Id: cabs.c,v 1.2 2002-10-28 08:11:29 pj Exp $ |
*/ |
/*--------------------------------------------------------------*/ |
/* TEST ON CABS */ |
/*--------------------------------------------------------------*/ |
64,12 → 103,12 |
/* Default action for an kern exception is */ |
kern_cli(); |
ll_gettime(TIME_EXACT, &t), |
kern_printf("\nS.Ha.R.K. Exception raised!!!" |
"\nTime (s:ns) :%ld:%ld" |
"\nException number:%d (numbers in include/bits/errno.h)" |
"\nPID :%d\n", |
t.tv_sec, t.tv_nsec, info->si_value.sival_int, |
info->si_task); |
cprintf("\nS.Ha.R.K. Exception raised!!!" |
"\nTime (s:ns) :%ld:%ld" |
"\nException number:%d (numbers in include/bits/errno.h)" |
"\nPID :%d\n", |
t.tv_sec, t.tv_nsec, info->si_value.sival_int, |
info->si_task); |
sys_abort(1); |
} |
109,7 → 148,7 |
void byebye(void *arg) |
{ |
grx_close(); |
kern_printf("Bye Bye!\n"); |
cprintf("Bye Bye!\n"); |
} |
/*--------------------------------------------------------------*/ |
145,10 → 184,9 |
} |
if (grx_open(640, 480, 8) < 0) { |
kern_printf("GRX Err\n"); |
cprintf("GRX Err\n"); |
sys_abort(1); |
} |
kern_printf("Video card ok!\n"); |
grx_clear(BLACK); |
/demos/tags/rel_0_2/base/ego.c |
---|
18,11 → 18,11 |
/** |
------------ |
CVS : $Id: ego.c,v 1.1.1.1 2002-09-02 09:37:41 pj Exp $ |
CVS : $Id: ego.c,v 1.2 2002-10-28 08:11:29 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1.1.1 $ |
Last update: $Date: 2002-09-02 09:37:41 $ |
Revision: $Revision: 1.2 $ |
Last update: $Date: 2002-10-28 08:11:29 $ |
------------ |
**/ |
126,12 → 126,12 |
/* Default action for an kern exception is */ |
kern_cli(); |
ll_gettime(TIME_EXACT, &t), |
kern_printf("\nS.Ha.R.K. Exception raised!!!" |
"\nTime (s:ns) :%ld:%ld" |
"\nException number:%d (numbers in include/bits/errno.h)" |
"\nPID :%d\n", |
t.tv_sec, t.tv_nsec, info->si_value.sival_int, |
info->si_task); |
cprintf("\nS.Ha.R.K. Exception raised!!!" |
"\nTime (s:ns) :%ld:%ld" |
"\nException number:%d (numbers in include/bits/errno.h)" |
"\nPID :%d\n", |
t.tv_sec, t.tv_nsec, info->si_value.sival_int, |
info->si_task); |
sys_abort(1); |
} |
166,7 → 166,7 |
void byebye(void *arg) |
{ |
grx_close(); |
kern_printf("Bye Bye!\n"); |
cprintf("Bye Bye!\n"); |
} |
/****************************** MAIN ******************************/ |
201,10 → 201,9 |
} |
if (grx_open(640, 480, 8) < 0) { |
kern_printf("GRX Err\n"); |
cprintf("GRX Err\n"); |
sys_abort(1); |
} |
kern_printf("Video card ok!\n"); |
/* set the keyboard handler to exit correctly */ |
emerg.ascii = 'x'; |
/demos/tags/rel_0_2/base/fly.c |
---|
18,11 → 18,11 |
/** |
------------ |
CVS : $Id: fly.c,v 1.1.1.1 2002-09-02 09:37:41 pj Exp $ |
CVS : $Id: fly.c,v 1.2 2002-10-28 08:11:29 pj Exp $ |
File: $File$ |
Revision: $Revision: 1.1.1.1 $ |
Last update: $Date: 2002-09-02 09:37:41 $ |
Revision: $Revision: 1.2 $ |
Last update: $Date: 2002-10-28 08:11:29 $ |
------------ |
**/ |
147,7 → 147,7 |
void byebye(void *arg) |
{ |
grx_close(); |
kern_printf("Bye Bye!\n"); |
cprintf("Bye Bye!\n"); |
} |
/****************************** MAIN ******************************/ |
172,10 → 172,9 |
} |
if (grx_open(640, 480, 8) < 0) { |
kern_printf("GRX Err\n"); |
cprintf("GRX Err\n"); |
sys_abort(1); |
} |
kern_printf("Video card ok!\n"); |
/* The scenario */ |
grx_rect(XMIN-D-1, YMIN-D-1, XMAX+D+1, YMAX+D+1, 14); |