/demos/trunk/first/test.c |
---|
0,0 → 1,334 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Giacomo Guidi <giacomo@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) 2002 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 "pthread.h" |
#include "modules/posix.h" |
#include "fsf_basic_types.h" |
#include "fsf_core.h" |
#include "fsf_hierarchical.h" |
#include "fsf_spare_capacity.h" |
#include "fsf_server.h" |
#include "modules/dummy.h" |
#include "modules/sem.h" |
#include "modules/pi.h" |
#include "modules/pc.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "drivers/keyb.h" |
#include <stdlib.h> |
#include "fsf_server.h" |
#include "fsf_basic_types.h" |
#include "fsf_core.h" |
// -------------------------------------------------- |
// -------------------------------------------------- |
// Init Part |
// -------------------------------------------------- |
// -------------------------------------------------- |
/*+ sysyem tick in us +*/ |
#define TICK 0 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
int grubstar_level; |
int posix_level; |
//fsf_shared_object_t obj; |
//fsf_shared_operation_t op; |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
posix_level=POSIX_register_level(RRTICK, 1, mb, 32); |
grubstar_level = GRUBSTAR_register_level(5, 0); |
FSF_register_module(posix_level,grubstar_level, (int)(MAX_BANDWIDTH * 0.9)); |
dummy_register_level(); |
// for the keyboard... |
CBS_register_level(CBS_ENABLE_ALL, 0); |
PI_register_module(); |
PC_register_module(); |
SEM_register_module(); |
PTHREAD_register_module(1, 0, 1); |
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; |
} |
// -------------------------------------------------- |
// -------------------------------------------------- |
// The Test |
// -------------------------------------------------- |
// -------------------------------------------------- |
pthread_t jposix = -1; |
pthread_t j1 = -1; |
pthread_t j2 = -1; |
fsf_server_id_t server1 = -1; |
fsf_server_id_t server2 = -1; |
fsf_contract_parameters_t contract; |
void *star(void *arg) |
{ |
struct timespec actual,end; |
int actpersecond,act; |
int cycle,rec; |
act = 0; |
actpersecond = 0; |
cycle = 0; |
rec = 0; |
for (;;) { |
cycle++; |
kern_gettime(&actual); |
rec = SERVER_get_last_reclaiming(grubstar_level,exec_shadow); |
if (act == 0) { |
TIMESPEC_ASSIGN(&end,&actual); |
end.tv_sec++; |
} |
if (TIMESPEC_A_LT_B(&actual,&end)) { |
act++; |
} else { |
actpersecond = act; |
act = 0; |
} |
//pthread_mutex_lock(&mux); |
printf_xy(0,exec_shadow,WHITE,"Thread %3d Act_per_Second = %8d cycle = %8d rec = %8d", |
exec_shadow,actpersecond,cycle,rec); |
//pthread_mutex_unlock(&mux); |
} |
return NULL; |
} |
void *periodic_star(void *arg) |
{ |
struct timespec actual,end; |
int actpersecond,act; |
int cycle,rec; |
act = 0; |
actpersecond = 0; |
cycle = 0; |
rec = 0; |
for (;;) { |
cycle++; |
kern_gettime(&actual); |
rec = SERVER_get_last_reclaiming(grubstar_level,exec_shadow); |
if (act == 0) { |
TIMESPEC_ASSIGN(&end,&actual); |
end.tv_sec++; |
} |
if (TIMESPEC_A_LT_B(&actual,&end)) { |
act++; |
} else { |
actpersecond = act; |
act = 0; |
} |
//fsf_lock_object(&op); |
printf_xy(0,exec_shadow,RED,"Thread %3d Act_per_Second = %8d cycle = %8d rec = %8d", |
exec_shadow,actpersecond,cycle,rec); |
//fsf_unlock_object(&op); |
task_endcycle(); |
} |
return NULL; |
} |
int keyinc = 5; |
void *edftask(void *arg) |
{ |
long long j; |
while(1) { |
for (j=0; j<10000*keyinc; j++); |
task_endcycle(); |
} |
return NULL; |
} |
void create() |
{ |
struct timespec period1 = {0,90000000}; //30% |
struct timespec period2 = {0,75000000}; //80% |
struct timespec budget1 = {0,30000000}; |
struct timespec budget2 = {0,60000000}; |
FSF_start_service_task(); |
kern_printf("(Start Create)"); |
fsf_initialize_contract(&contract); |
fsf_set_contract_basic_parameters(&contract,&budget1,&period1,FSF_DEFAULT_WORKLOAD); |
fsf_set_contract_scheduling_policy(&contract, FSF_EDF); |
fsf_set_contract_reclamation_parameters(&contract,&budget2, &period2, FSF_DEFAULT_GRANULARITY, NULL, 1, 0); |
fsf_negotiate_contract(&contract,&server1); |
fsf_set_contract_basic_parameters(&contract,&budget1,&period1,FSF_DEFAULT_WORKLOAD); |
fsf_set_contract_scheduling_policy(&contract, FSF_EDF); |
fsf_set_contract_reclamation_parameters(&contract,&budget2, &period2,FSF_DEFAULT_GRANULARITY, NULL, 1, 1); |
fsf_negotiate_contract(&contract,&server2); |
kern_printf("(End Create)"); |
} |
void renegotiate(void) { |
struct timespec period2 = {0,75000000}; |
struct timespec budget2 = {0,60000000}; |
struct timespec budget1 = {0,60000000}; |
union sigval sval; |
for (;;) { |
fsf_set_contract_basic_parameters(&contract,&budget2,&period2,FSF_DEFAULT_WORKLOAD); |
fsf_set_contract_reclamation_parameters(&contract,&budget1, &period2,FSF_DEFAULT_GRANULARITY, NULL, 20, 0); |
//fsf_request_contract_renegotiation(&contract,server2, 0, sval); |
fsf_renegotiate_contract(&contract, server2); |
budget2.tv_nsec -=60000; |
task_endcycle(); |
} |
} |
int main(int argc, char **argv) |
{ |
int err; |
HARD_TASK_MODEL ht; |
struct timespec endtimer; |
//fsf_init_shared_object(&obj,1); |
//op.op_id=1; |
//op.wcet.tv_sec=0; |
//op.wcet.tv_nsec=100000; |
//fsf_declare_shared_object_operation(&obj, &op); |
srand(kern_gettime(NULL)); |
create(); |
kern_gettime(&endtimer); |
endtimer.tv_sec += 20; |
kern_event_post(&endtimer, (void (*)(void *))(sys_end), NULL); |
hard_task_default_model(ht); |
hard_task_def_mit(ht,200000); |
hard_task_def_wcet(ht,5000); |
err = fsf_create_thread(server1,&j1,NULL,periodic_star,NULL,&ht); |
kern_printf("(%d)",err); |
task_activate(j1); |
hard_task_default_model(ht); |
hard_task_def_mit(ht,1000000); |
hard_task_def_wcet(ht,50000); |
err = fsf_create_thread(server1,&j1,NULL,renegotiate,NULL,&ht); |
kern_printf("(%d)",err); |
task_activate(j1); |
hard_task_default_model(ht); |
hard_task_def_mit(ht,159000); |
hard_task_def_wcet(ht,5000); |
err = fsf_create_thread(server2,&j2,NULL,periodic_star,NULL,&ht); |
kern_printf("(%d)",err); |
task_activate(j2); |
hard_task_default_model(ht); |
hard_task_def_mit(ht,159000); |
hard_task_def_wcet(ht,5000); |
err = fsf_create_thread(server2,&j2,NULL,periodic_star,NULL,&ht); |
kern_printf("(%d)",err); |
task_activate(j2); |
return 0; |
} |
/demos/trunk/first/test1.c |
---|
0,0 → 1,386 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Giacomo Guidi <giacomo@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) 2002 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 "pthread.h" |
#include "modules/posix.h" |
#include "fsf.h" |
#include "grubstar.h" |
#include "fsf_server.h" |
#include "modules/dummy.h" |
#include "modules/sem.h" |
#include "modules/pi.h" |
#include "modules/pc.h" |
#include "modules/hartport.h" |
#include "modules/cabs.h" |
#include "drivers/keyb.h" |
#include <stdlib.h> |
// -------------------------------------------------- |
// -------------------------------------------------- |
// Init Part |
// -------------------------------------------------- |
// -------------------------------------------------- |
/*+ sysyem tick in us +*/ |
#define TICK 0 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
int grubstar_level; |
int posix_level; |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
EDF_register_level(EDF_ENABLE_ALL); |
posix_level=POSIX_register_level(RRTICK, 1, mb, 32); |
grubstar_level = GRUBSTAR_register_level(5, 0); |
FSF_register_module(posix_level,grubstar_level, (int)(MAX_BANDWIDTH * 0.9)); |
dummy_register_level(); |
// for the keyboard... |
CBS_register_level(CBS_ENABLE_ALL, 0); |
PI_register_module(); |
PC_register_module(); |
SEM_register_module(); |
PTHREAD_register_module(1, 0, 1); |
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; |
} |
// -------------------------------------------------- |
// -------------------------------------------------- |
// The Test |
// -------------------------------------------------- |
// -------------------------------------------------- |
pthread_t j1 = -1; |
pthread_t j2 = -1; |
pthread_t j3 = -1; |
pthread_t j4 = -1; |
fsf_server_id_t server1 = -1; |
fsf_server_id_t server2 = -1; |
fsf_server_id_t server3 = -1; |
fsf_server_id_t server4 = -1; |
fsf_contract_parameters_t contract1, contract2; |
#define TASK_PERIOD 1000000 |
void *periodic_star(void *arg) |
{ |
struct timespec actual,end,next_time; |
int actpersecond,act,cycle; |
int mean,nmean; |
bool was_deadline_missed, was_budget_overran; |
act = 0; |
actpersecond = 0; |
mean = 0; |
nmean = 0; |
cycle = 0; |
for (;;) { |
kern_gettime(&actual); |
cycle++; |
if (act == 0) { |
TIMESPEC_ASSIGN(&end,&actual); |
end.tv_sec++; |
} |
if (TIMESPEC_A_LT_B(&actual,&end)) { |
act++; |
} else { |
actpersecond = act; |
act = 0; |
mean = (mean * nmean + actpersecond) / (nmean+1); |
nmean++; |
} |
printf_xy(0,exec_shadow,WHITE,"Thread %3d Act_per_Second = %8d Mean = %8d Cycle = %8d", |
exec_shadow,actpersecond,mean,cycle); |
kern_gettime(&next_time); |
ADDUSEC2TIMESPEC(TASK_PERIOD, &next_time); |
fsf_schedule_next_timed_job(&next_time, NULL, NULL, &was_deadline_missed, &was_budget_overran); |
} |
return NULL; |
} |
void *star(void *arg) |
{ |
struct timespec actual,end; |
int actpersecond,act; |
int mean,nmean,cycle; |
act = 0; |
actpersecond = 0; |
mean = 0; |
nmean = 0; |
cycle = 0; |
for (;;) { |
cycle++; |
kern_gettime(&actual); |
if (act == 0) { |
TIMESPEC_ASSIGN(&end,&actual); |
end.tv_sec++; |
} |
if (TIMESPEC_A_LT_B(&actual,&end)) { |
act++; |
} else { |
actpersecond = act; |
act = 0; |
mean = (mean * nmean + actpersecond) / (nmean+1); |
nmean++; |
} |
printf_xy(0,exec_shadow,WHITE,"Thread %3d Act_per_Second = %8d Mean = %8d Cycle = %8d", |
exec_shadow,actpersecond,mean,cycle); |
} |
return NULL; |
} |
void *edftask(void *arg) |
{ |
int i,j; |
while(1) { |
for (i=0;i<5; i++) { |
for (j=0; j<10; j++); |
//cputc('#'); |
//cputs((char *)(arg)); |
} |
task_endcycle(); |
} |
return NULL; |
} |
void create() |
{ |
HARD_TASK_MODEL mhard; |
struct timespec period1 = {0,100000000}; |
struct timespec period2 = {0,100000000}; |
struct timespec budget1 = {0,30000000}; |
struct timespec budget2 = {0,30000000}; |
PID t1, t2; |
int err; |
FSF_start_service_task(); |
kern_printf("(Start Create)"); |
hard_task_default_model(mhard); |
hard_task_def_ctrl_jet(mhard); |
hard_task_def_mit(mhard,32000); |
hard_task_def_wcet(mhard,3000); |
hard_task_def_arg(mhard,(void *)"X"); |
hard_task_def_group(mhard,1); |
hard_task_def_periodic(mhard); |
//t1 = task_create("X", edftask, &mhard, NULL); |
//if (t1 == NIL) { |
// perror("Could not create task X ..."); |
// sys_end(); |
//} |
hard_task_def_mit(mhard,32000); |
hard_task_def_wcet(mhard,3000); |
hard_task_def_arg(mhard,(void *)"Y"); |
//t2 = task_create("Y", edftask, &mhard, NULL); |
//if (t2 == NIL) { |
// perror("Could not create task Y ..."); |
// sys_end(); |
//} |
//group_activate(1); |
err = pthread_create(&j1, NULL, star, (void *)"A"); |
if (err) { |
perror("Could not create task A ..."); |
sys_end(); |
} |
err = pthread_create(&j2, NULL, periodic_star, (void *)"B"); |
if (err) { |
perror("Could not create task B ..."); |
sys_end(); |
} |
err = pthread_create(&j3, NULL, star, (void *)"C"); |
if (err) { |
perror("Could not create task C ..."); |
sys_end(); |
} |
err = pthread_create(&j4, NULL, periodic_star, (void *)"D"); |
if (err) { |
perror("Could not create task D ..."); |
sys_end(); |
} |
fsf_initialize_contract(&contract1); |
fsf_set_contract_basic_parameters(&contract1,&budget1,&period1,FSF_DEFAULT_WORKLOAD); |
fsf_initialize_contract(&contract2); |
fsf_set_contract_basic_parameters(&contract2,&budget2,&period2,FSF_DEFAULT_WORKLOAD); |
kern_printf("(End Create)"); |
} |
int main(int argc, char **argv) |
{ |
char ch = 0; |
int err; |
create(); |
do { |
ch = keyb_getch(BLOCK); |
switch(ch) { |
case '1': |
err = fsf_bind_thread_to_server(server1,j1); |
kern_printf("(%d)",err); |
break; |
case '2': |
err = fsf_bind_thread_to_server(server2,j2); |
kern_printf("(%d)",err); |
break; |
case '3': |
err = fsf_bind_thread_to_server(server1,j3); |
kern_printf("(%d)",err); |
break; |
case '4': |
err = fsf_bind_thread_to_server(server2,j4); |
kern_printf("(%d)",err); |
break; |
case '5': |
err = fsf_unbind_thread_from_server(j1); |
kern_printf("(%d)",err); |
break; |
case '6': |
err = fsf_unbind_thread_from_server(j2); |
kern_printf("(%d)",err); |
break; |
case '7': |
err = fsf_unbind_thread_from_server(j3); |
kern_printf("(%d)",err); |
break; |
case '8': |
err = fsf_unbind_thread_from_server(j4); |
kern_printf("(%d)",err); |
break; |
case 'q': |
err = fsf_negotiate_contract(&contract1,&server1); |
cprintf("(%d)",err); |
break; |
case 'w': |
err = fsf_negotiate_contract(&contract2,&server2); |
kern_printf("(%d)",err); |
break; |
case 'e': |
err = fsf_negotiate_contract(&contract1,&server3); |
kern_printf("(%d)",err); |
break; |
case 'r': |
err = fsf_cancel_contract(server1); |
kern_printf("(%d)",err); |
break; |
case 't': |
err = fsf_cancel_contract(server2); |
kern_printf("(%d)",err); |
break; |
case 'y': |
err = fsf_cancel_contract(server3); |
kern_printf("(%d)",err); |
break; |
} |
} while(ch != ESC); |
sys_end(); |
return 0; |
} |
/demos/trunk/first/test2.c |
---|
0,0 → 1,416 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Giacomo Guidi <giacomo@gandalf.sssup.it> |
* |
* 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 |
*/ |
#include "kernel/kern.h" |
#include "fsf.h" |
#include "stdlib.h" |
#include "unistd.h" |
#include "string.h" |
#include "pistar.h" |
#include "pthread.h" |
#include "drivers/glib.h" |
#include <tracer.h> |
#include "FTrace_udp.h" |
#include "FTrace_chunk.h" |
#include <drivers/shark_keyb26.h> |
#define TEST_PERIOD 50000 |
mutex_t mux; |
int main_chunk; |
TASK finish_task() { |
#ifdef __NEW_TRACER__ |
group_kill(1); |
group_kill(2); |
FTrace_OSD_init_udp(1,"192.168.82.43","192.168.82.41"); |
FTrace_send_chunk(main_chunk, 0, FTRACE_CHUNK_FLAG_FREE | FTRACE_CHUNK_FLAG_CYC); |
sys_end(); |
#else |
sys_end(); |
#endif |
return NULL; |
} |
void print_timer(int x, int y) |
{ |
long nsec,sec,min,hrs,day; |
struct timespec actual_timer; |
char tmp[100]; |
sys_gettime(&actual_timer); |
nsec = actual_timer.tv_nsec; |
sec = actual_timer.tv_sec; |
min = sec / 60; |
sec %= 60; |
hrs = min / 60; |
min %= 60; |
day = hrs / 24; |
hrs %= 24; |
sprintf(tmp,"Time: %2ld d %2ld h %2ld m %2ld s %12ld ns",day,hrs,min,sec,(long)nsec); |
mutex_lock(&mux); |
grx_text(tmp,x,y,rgb16(255,255,255),0); |
mutex_unlock(&mux); |
} |
#define LOAD_VARIATION 10 |
#define MAX_V_QOS 30 |
#define MIN_V_QOS 2 |
void *test_task_variable(void *arg) { |
struct timespec next_time; |
bool was_deadline_missed = false, was_budget_overran = false; |
char tmp[100]; |
long long i; |
int task_qos; |
int var_load, rd_per; |
TIME exectime; |
task_qos = 7; |
var_load = 5; |
rd_per = 0; |
while(1) { |
print_timer(307,10+30*exec_shadow); |
sprintf(tmp,"Test Thread V QOS = %5d PID = %3d VLOAD = %3d",task_qos,exec_shadow,var_load); |
mutex_lock(&mux); |
if (!was_deadline_missed) |
grx_text(tmp,307,20+30*exec_shadow,rgb16(255,255,255),0); |
else |
grx_text(tmp,307,20+30*exec_shadow,rgb16(255,0,0),0); |
mutex_unlock(&mux); |
//jet_gettable(exec_shadow, &exectime, 1); |
//sprintf(tmp,"Thread Exec Timer = %10d us",(int)exectime); |
//grx_text(tmp,307,30+30*exec_shadow,rgb16(255,255,255),0); |
if (rd_per > LOAD_VARIATION) { |
var_load += rand()%3-1; |
if (var_load > 20) var_load = 20; |
if (var_load < 0) var_load = 0; |
rd_per = 0; |
} else { |
rd_per++; |
} |
for(i = 0; i < 10000*(task_qos+var_load); i++); |
} |
return NULL; |
} |
#define MAX_C_QOS 30 |
#define MIN_C_QOS 2 |
void *test_task_constant(void *arg) { |
struct timespec next_time; |
bool was_deadline_missed = false, was_budget_overran = false; |
char tmp[100]; |
long long i; |
int task_qos; |
task_qos = 7; |
while(1) { |
print_timer(307,10+20*exec_shadow); |
sprintf(tmp,"Test Task C QOS = %5d PID = %3d",task_qos,exec_shadow); |
mutex_lock(&mux); |
if (!was_deadline_missed) |
grx_text(tmp,307,20+20*exec_shadow,rgb16(255,255,255),0); |
else |
grx_text(tmp,307,20+20*exec_shadow,rgb16(255,0,0),0); |
mutex_unlock(&mux); |
for(i = 0; i < 10000*task_qos; i++); |
} |
return NULL; |
} |
void draw_box(int x1, int y1, int x2, int y2) |
{ |
grx_rect(x1,y1,x2,y2,rgb16(160,160,160)); |
grx_rect(x1+2,y1+2,x2-2,y2-2,rgb16(210,210,210)); |
} |
void layout_screen() |
{ |
draw_box(0,0,300,500); |
grx_text("Application Task List",5,5,rgb16(255,255,255),0); |
draw_box(303,0,799,500); |
grx_text("Task Output",305,5,rgb16(255,255,255),0); |
draw_box(0,503,799,599); |
grx_line(140,505,140,597,rgb16(255,255,255)); |
grx_line(140,583,797,583,rgb16(255,255,255)); |
grx_text("Application Statistics",142,507,rgb16(255,255,255),0); |
} |
void program_end() |
{ |
grx_close(); |
} |
void *mpeg2decoder(void *arg); |
void add_posixstar_thread(fsf_server_id_t server) |
{ |
int err; |
pthread_t j = -1; |
NRT_TASK_MODEL nrt; |
nrt_task_default_model(nrt); |
nrt_task_def_save_arrivals(nrt); |
nrt_task_def_group(nrt,1); |
err = pthread_create(&j, NULL, test_task_variable, NULL); |
if (err) { |
perror("Could not create task..."); |
sys_end(); |
} |
err=fsf_bind_local_thread_to_server(server, j, (fsf_sched_params_t *)(&nrt)); |
if (err) { |
grx_close(); |
kern_printf("Could not bind task.. %d", err); |
sys_end(); |
} |
} |
void add_edfstar_thread(fsf_server_id_t server) |
{ |
int err; |
pthread_t j = -1; |
HARD_TASK_MODEL ht; |
hard_task_default_model(ht); |
hard_task_def_mit(ht,100000); |
hard_task_def_wcet(ht,90000); |
nrt_task_def_group(ht,2); |
err = pthread_create(&j, NULL, mpeg2decoder, NULL); |
if (err) { |
grx_close(); |
perror("Could not create task..."); |
sys_end(); |
} |
err=fsf_bind_local_thread_to_server(server, j,(fsf_sched_params_t *)(&ht)); |
if (err) { |
grx_close(); |
perror("Could not bind task.."); |
sys_end(); |
} |
} |
void ending_system(KEY_EVT *e) { |
grx_close(); |
#ifdef __NEW_TRACER__ |
NRT_TASK_MODEL nrt; |
TRACER_LOGEVENT(FTrace_EVT_trace_stop,0,0); |
FTrace_disable(); |
//group_kill(l->group); |
nrt_task_default_model(nrt); |
task_activate(task_create("Finish",finish_task,&nrt,NULL)); |
#else |
sys_end(); |
#endif |
} |
int main(int argc, char **argv) |
{ |
char ch; |
int err; |
//KEY_EVT k; |
PI_mutexattr_t a; |
KEY_EVT ev; |
struct timespec period = {0,10000000}; |
struct timespec budget = {0,1000000}; |
struct timespec period1 = {0,10000000}; |
struct timespec period2 = {0,10000000}; |
struct timespec budget1 = {0,3000000}; |
struct timespec budget2 = {0,3000000}; |
fsf_server_id_t server1, server2; |
fsf_contract_parameters_t contract1, contract2; |
union sigval sval; |
ev.ascii = 'c'; |
ev.scan = KEY_C; |
ev.status = KEY_PRESSED; |
ev.flag = CNTR_BIT; |
keyb_hook(ev, ending_system, FALSE); |
#ifdef __NEW_TRACER__ |
main_chunk = FTrace_chunk_create(10000000, 1000, FTRACE_CHUNK_FLAG_FREE | FTRACE_CHUNK_FLAG_CYC); |
FTrace_actual_chunk_select(main_chunk); |
FTrace_enable(); |
#endif |
TRACER_LOGEVENT(FTrace_EVT_trace_start,0,0); |
PI_mutexattr_default(a); |
FSF_start_service_task(); |
mutex_init(&mux,&a); |
fsf_initialize_contract(&contract1); |
fsf_set_contract_basic_parameters(&contract1,&budget1,&period1,FSF_DEFAULT_WORKLOAD); |
fsf_initialize_contract(&contract2); |
fsf_set_contract_scheduling_policy(&contract1, FSF_POSIX); |
fsf_set_contract_basic_parameters(&contract2,&budget2,&period2,FSF_DEFAULT_WORKLOAD); |
fsf_set_contract_scheduling_policy(&contract2, FSF_EDF); |
err = fsf_negotiate_contract(&contract1,&server1); |
if (err) cprintf("(FSF ERROR %d)",err); |
err = fsf_negotiate_contract(&contract2,&server2); |
if (err) cprintf("(FSF ERROR %d)",err); |
//graphic card Initialization |
if (grx_init() < 1) { |
sys_end(); |
} |
if (grx_open(800, 600, 16) < 0) { |
cprintf("GRX Err\n"); |
sys_end(); |
} |
layout_screen(); |
ch = keyb_getch(BLOCK); |
while(ch != ESC) { |
switch (ch) { |
case '1': |
add_posixstar_thread(server1); |
break; |
case '2': |
add_edfstar_thread(server2); |
break; |
case '3': |
fsf_set_contract_basic_parameters(&contract2,&budget,&period,FSF_DEFAULT_WORKLOAD); |
fsf_request_contract_renegotiation(&contract2,server2, 0, sval); |
break; |
case '4': |
ending_system(NULL); |
break; |
case '5': |
break; |
} |
ch = keyb_getch(BLOCK); |
} |
ending_system(NULL); |
return 0; |
} |
/demos/trunk/first/initfile.c |
---|
0,0 → 1,206 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: |
* Giorgio Buttazzo <giorgio@sssup.it> |
* Paolo Gai <pj@gandalf.sssup.it> |
* |
* Authors : |
* Giacomo Guidi <giacomo@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 |
* |
*/ |
#include "kernel/kern.h" |
#include "modules/edf.h" |
#include "modules/cbs.h" |
#include "modules/posix.h" |
#include "pthread.h" |
#include "modules/sem.h" |
#include "modules/dummy.h" |
#include "modules/hartport.h" |
#include "grubstar.h" |
#include "fsf.h" |
#include "modules/pi.h" |
#include "modules/pc.h" |
#include "modules/intdrive.h" |
#include <drivers/shark_linuxc26.h> |
#include <drivers/shark_input26.h> |
#include <drivers/shark_keyb26.h> |
#include <drivers/shark_pci26.h> |
#define TICK 0 |
#define RRTICK 10000 |
/*+ Interrupt Server +*/ |
#define INTDRIVE_Q 1000 |
#define INTDRIVE_T 10000 |
#define INTDRIVE_FLAG 0 |
void call_shutdown_task(void *arg); |
int device_drivers_init(); |
int device_drivers_close(); |
void set_shutdown_task(); |
TASK shutdown_task_body(void *arg); |
PID shutdown_task_PID = 1; |
void load_file(); |
int device_drivers_close() { |
KEYB26_close(); |
INPUT26_close(); |
return 0; |
} |
int device_drivers_init() { |
KEYB_PARMS kparms = BASE_KEYB; |
LINUXC26_register_module(); |
PCI26_init(); |
INPUT26_init(); |
/*keyb_def_map(kparms, KEYMAP_IT);*/ |
keyb_def_ctrlC(kparms, NULL); |
KEYB26_init(&kparms); |
return 0; |
} |
TASK shutdown_task_body(void *arg) { |
device_drivers_close(); |
sys_shutdown_message("-- S.Ha.R.K. Closed --\n"); |
sys_abort_shutdown(0); |
return NULL; |
} |
#define SHUTDOWN_TIMEOUT_SEC 3 |
void set_shutdown_task() { |
NRT_TASK_MODEL nrt; |
nrt_task_default_model(nrt); |
nrt_task_def_system(nrt); |
shutdown_task_PID = task_create("Shutdown Task", shutdown_task_body, &nrt, NULL); |
if (shutdown_task_PID == NIL) { |
sys_shutdown_message("Error: Cannot create shutdown task\n"); |
sys_end(); |
} |
} |
void call_shutdown_task(void *arg) { |
struct timespec t; |
sys_gettime(&t); |
t.tv_sec += SHUTDOWN_TIMEOUT_SEC; |
/* Emergency timeout to exit from RUNLEVEL_SHUTDOWN */ |
kern_event_post(&t,(void *)((void *)sys_abort_shutdown),(void *)0); |
task_activate(shutdown_task_PID); |
} |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
int edf_level; |
int grubstar_level; |
int posix_level; |
int pi_level; |
int pc_level; |
INTDRIVE_register_level(INTDRIVE_Q, INTDRIVE_T, INTDRIVE_FLAG); |
edf_level=EDF_register_level(EDF_ENABLE_ALL); |
posix_level=POSIX_register_level(RRTICK, edf_level, mb, 32); |
grubstar_level = GRUBSTAR_register_level(FSF_MAX_N_SERVERS, edf_level); |
FSF_register_module(posix_level,grubstar_level, (int)(MAX_BANDWIDTH*0.8)); |
dummy_register_level(); |
CBS_register_level(CBS_ENABLE_ALL,1); |
SEM_register_module(); |
pi_level=PI_register_module(); |
pc_level=PC_register_module(); |
PTHREAD_register_module(posix_level, pi_level, pc_level); |
load_file(); |
return TICK; |
} |
TASK __init__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
HARTPORT_init(); |
set_shutdown_task(); |
device_drivers_init(); |
sys_atrunlevel(call_shutdown_task, NULL, RUNLEVEL_SHUTDOWN); |
__call_main__(mb); |
return (void *)0; |
} |
int dos_video_preload(void *filename, long max_size, void **start, void **end); |
void *start_file; |
void *end_file; |
void load_file() |
{ |
start_file = NULL; |
end_file = NULL; |
dos_video_preload("test.m2v",5000000,&start_file,&end_file); |
cprintf("Start file ptr = %08lx\n",(long)(start_file)); |
cprintf("End file ptr = %08lx\n",(long)(end_file)); |
cprintf("Size = %8ld\n",(long)(end_file - start_file)); |
} |
/demos/trunk/first/demos.txt |
---|
0,0 → 1,48 |
FSF demo for S.Ha.R.K |
test1.c: |
This demo shows the main feature of service contract implementation. |
A set of 4 threads is created using the pthread standard functions. |
At the beginning, these threads run without temporal restrictions |
and they don't respect any deadline. |
Two service contracts are initialized and set |
fsf_initialize_contract(&contract1); |
fsf_initialize_contract(&contract2); |
fsf_set_contract_basic_parameters(&contract1,&budget1,&period1,NULL,NULL,FSF_DEFAULT_WORKLOAD); |
fsf_set_contract_basic_parameters(&contract2,&budget2,&period2,NULL,NULL,FSF_DEFAULT_WORKLOAD); |
whit the button 'q','w','e' you can respectively |
negotiate contract for a server |
[err = fsf_negotiate_contract(&contractX,&serverY);] |
'q' -> negotiate contract1 for server1 |
'w' -> negotiate contract2 for server2 |
'e' -> negotiate contract1 for server3 |
now with button '1','2','3','4' you can bind the thread to a server |
[err = fsf_bind_thread_to_server(serverY,jZ);] |
'1' -> bind thread1 to server1 |
'2' -> bind thread2 to server2 |
'3' -> bind thread3 to server3 |
'4' -> bind thread4 to server2 |
threads will start to respect the assigned budget. It's possible |
to bind more threads to one server. The local scheduler specified in the |
contract define how the threads will get the server resources. |
With '5','6','7','8' the thread is unbind from the server |
[err = fsf_unbind_thread_from_server(jZ);] |
With 'r','t','y' a server is removed |
[err = fsf_cancel_contract(&server2);] |
/demos/trunk/first/makefile |
---|
0,0 → 1,24 |
# |
# |
BASE=../.. |
include $(BASE)/config/config.mk |
PROGS= test test1 test2 |
MPEG2 = ./mpeg2/getbits.o ./mpeg2/getblk.o ./mpeg2/gethdr.o ./mpeg2/getpic.o\ |
./mpeg2/getvlc.o ./mpeg2/idct.o ./mpeg2/idctref.o ./mpeg2/motion.o\ |
./mpeg2/mpeg2dec.o ./mpeg2/recon.o ./mpeg2/spatscal.o ./mpeg2/store.o\ |
./mpeg2/subspic.o ./mpeg2/systems.o ./mpeg2/verify.o ./mpeg2/gvideo.o |
include $(BASE)/config/example.mk |
test: |
make -f $(SUBMAKE) APP=test INIT= OTHEROBJS= OTHERINCL= SHARKOPT="__OLDCHAR__ __FIRST__ __NEW_TRACER__" |
test1: |
make -f $(SUBMAKE) APP=test1 INIT= OTHEROBJS= OTHERINCL= SHARKOPT="__OLDCHAR__ __FIRST__ __NEW_TRACER__" |
test2: |
make -f $(SUBMAKE) APP=test2 INIT= OTHEROBJS="initfile.o $(MPEG2)" OTHERINCL= SHARKOPT="__INPUT__ __FIRST__ __NEW_TRACER__ __LINUXC26__ __PCI__ __NET__ __GRX__" |