Subversion Repositories shark

Compare Revisions

Regard whitespace Rev 1540 → Rev 1541

/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__"