/demos/trunk/loader/shark/initfile.c |
---|
0,0 → 1,182 |
/* |
* Project: S.Ha.R.K. |
* |
* Coordinators: Giorgio Buttazzo <giorgio@sssup.it> |
* |
* Authors : |
* Mauro Marinoni <mauro.marinoni@unipv.it> |
* Tullio Facchinetti <tullio.facchinetti@unipv.it> |
* (see authors.txt for full list of hartik's authors) |
* |
* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy) |
* |
* http://www.sssup.it |
* http://retis.sssup.it |
* http://hartik.sssup.it |
*/ |
/* |
* 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 "edf/edf/edf.h" |
#include "cbs/cbs/cbs.h" |
#include "rr/rr/rr.h" |
#include "dummy/dummy/dummy.h" |
#include "intdrive/intdrive/intdrive.h" |
#include "posix/posix/posix.h" |
#include "grubstar.h" |
#include "fsf_basic_types.h" |
#include "fsf_core.h" |
#include "pi/pi/pi.h" |
#include "pc/pc/pc.h" |
#include "pthread.h" |
#include "sem/sem/sem.h" |
#include "hartport/hartport/hartport.h" |
#include "nop/nop/nop.h" |
#include <drivers/shark_linuxc26.h> |
#include <drivers/shark_pci26.h> |
/*+ sysyem tick in us +*/ |
#define TICK 0 |
/*+ RR tick in us +*/ |
#define RRTICK 10000 |
/*+ Interrupt Server +*/ |
#define INTDRIVE_Q 1000 |
#define INTDRIVE_U 0.1*MAX_BANDWIDTH |
#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; |
TIME __kernel_register_levels__(void *arg) |
{ |
struct multiboot_info *mb = (struct multiboot_info *)arg; |
int grubstar_level; |
int posix_level; |
int pi_level; |
int pc_level; |
LEVEL EDF_level; |
INTDRIVE_register_level(INTDRIVE_Q, INTDRIVE_Q, INTDRIVE_U, INTDRIVE_FLAG); |
EDF_level = EDF_register_level(EDF_ENABLE_ALL); |
posix_level=POSIX_register_level(RRTICK, 1, mb, 32); |
grubstar_level = GRUBSTAR_register_level(FSF_MAX_N_SERVERS, 1); |
FSF_register_module(posix_level,grubstar_level, (int)(MAX_BANDWIDTH * 0.8)); |
dummy_register_level(); |
//posix_level=POSIX_register_level(RRTICK, 1, mb, 32); |
CBS_register_level(CBS_ENABLE_ALL,EDF_level); |
SEM_register_module(); |
pi_level=PI_register_module(); |
pc_level=PC_register_module(); |
NOP_register_module(); |
PTHREAD_register_module(2, pi_level, pc_level); |
return TICK; |
} |
int device_drivers_close() { |
return 0; |
} |
int device_drivers_init() { |
LINUXC26_register_module(TRUE); |
PCI26_init(); |
return 0; |
} |
TASK shutdown_task_body(void *arg) { |
device_drivers_close(); |
sys_shutdown_message("-- S.Ha.R.K. Closed --\n"); |
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"); |
exit(0); |
} |
} |
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); |
} |
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 main() { |
return start_environment(); |
} |
/demos/trunk/loader/shark/fsfinit.c |
---|
0,0 → 1,62 |
#include "kernel/kern.h" |
#include "fsf.h" |
#include "fsf_server.h" |
#include "func.h" |
extern struct loader_contract loader_contract_list[]; |
extern int total_loader_contract; |
void fsfinit() |
{ |
struct loader_contract *c; |
fsf_contract_parameters_t contract; |
fsf_server_id_t server; |
union sigval no_sigval = {0}; |
int i; |
int err=0; |
FSF_start_service_task(); |
for (i=0;i<total_loader_contract;i++) { |
c = &loader_contract_list[i]; |
fsf_initialize_contract(&contract); |
err=fsf_set_contract_basic_parameters(&contract,&c->cmin,&c->tmax,c->workload); |
if (err) exit(err); |
err=fsf_set_contract_reclamation_parameters(&contract,&c->cmax,&c->tmin,FSF_DEFAULT_GRANULARITY, NULL, 1,1); |
if (err) exit(err); |
if (TIMESPEC2USEC(&c->deadline) != 0) |
err=fsf_set_contract_timing_requirements(&contract,false,&c->deadline,0,no_sigval,0,no_sigval); |
else |
err=fsf_set_contract_timing_requirements(&contract,true,NULL,0,no_sigval,0,no_sigval); |
if (err) exit(err); |
switch (c->local_scheduler) { |
case PAR_EDF: |
fsf_set_contract_scheduling_policy(&contract,FSF_EDF); |
break; |
case PAR_RM: |
fsf_set_contract_scheduling_policy(&contract,FSF_FP); |
break; |
case PAR_POSIX: |
fsf_set_contract_scheduling_policy(&contract,FSF_RR); |
break; |
} |
err=fsf_negotiate_contract(&contract,&server); |
if (err) exit(err); |
c->server = server; |
} |
print_server_list(); |
} |
/demos/trunk/loader/shark/shark.c |
---|
0,0 → 1,267 |
#include "func.h" |
#include "calibrate.h" |
#include <tracer.h> |
#include "FTrace_udp.h" |
#include "FTrace_chunk.h" |
extern int cal_cycles; |
extern struct timespec zero_time; |
extern struct loader_task loader_task_list[]; |
extern struct loader_contract loader_contract_list[]; |
extern int total_loader_task; |
extern int total_loader_contract; |
extern unsigned int clk_per_msec; |
mutex_t mutex_table[MAX_MUTEX]; |
int main_chunk; |
/* Runtime Calibration */ |
int calibrate_cycle() |
{ |
long long i; |
struct timespec start,end,diff; |
if (cal_cycles != 0) return 0; |
kern_cli(); |
__asm__ __volatile__ ("xorl %%eax,%%eax\n\t" |
"cpuid\n\t" |
:::"eax","ebx","ecx","edx"); |
kern_gettime(&start); |
for (i=0;i<CALIBRATION_DELTA;i++) |
__asm__ __volatile__ ("xorl %%eax,%%eax\n\t" |
"cpuid\n\t" |
:::"eax","ebx","ecx","edx"); |
__asm__ __volatile__ ("xorl %%eax,%%eax\n\t" |
"cpuid\n\t" |
:::"eax","ebx","ecx","edx"); |
kern_gettime(&end); |
kern_sti(); |
SUBTIMESPEC(&end,&start,&diff); |
cal_cycles = TIMESPEC2USEC(&diff); |
cprintf("Calibration usec/[%d cycles] = %d\n",CALIBRATION_DELTA,cal_cycles); |
return 0; |
} |
int get_server_from_contract(int contract) |
{ |
int i; |
for(i=0;i<total_loader_contract;i++) |
if (loader_contract_list[i].number == contract) |
return loader_contract_list[i].server; |
return -1; |
} |
void *get_task_model(struct loader_task *current) { |
if (current->local_scheduler == PAR_POSIX) { |
static NRT_TASK_MODEL nrt; |
static fsf_sched_params_t pr; |
pr.policy=FSF_RR; |
pr.params=&nrt; |
nrt_task_default_model(nrt); |
nrt_task_def_save_arrivals(nrt); |
nrt_task_def_ctrl_jet(nrt); |
nrt_task_def_group(nrt,current->group); |
nrt_task_def_usemath(nrt); |
return ≺ |
} |
if (current->local_scheduler == PAR_EDF) { |
static HARD_TASK_MODEL ht; |
static fsf_sched_params_t pr; |
pr.policy=FSF_EDF; |
pr.params=&ht; |
hard_task_default_model(ht); |
hard_task_def_ctrl_jet(ht); |
hard_task_def_mit(ht,TIMESPEC2USEC(¤t->deadline)); |
hard_task_def_wcet(ht,TIMESPEC2USEC(¤t->wcet)); |
hard_task_def_group(ht,current->group); |
hard_task_def_aperiodic(ht); |
hard_task_def_usemath(ht); |
return ≺ |
} |
if (current->local_scheduler == PAR_NONE) { |
static DUMMY_TASK_MODEL d; |
static fsf_sched_params_t pr; |
pr.policy=FSF_NONE; |
pr.params=&d; |
dummy_task_default_model(d); |
dummy_task_def_group(d,current->group); |
return ≺ |
} |
if (current->local_scheduler == PAR_RM) { |
static HARD_TASK_MODEL ht; |
static fsf_sched_params_t pr; |
pr.policy=FSF_FP; |
pr.params=&ht; |
hard_task_default_model(ht); |
hard_task_def_mit(ht,TIMESPEC2USEC(¤t->deadline)); |
hard_task_def_wcet(ht,TIMESPEC2USEC(¤t->wcet)); |
hard_task_def_ctrl_jet(ht); |
hard_task_def_group(ht,current->group); |
hard_task_def_usemath(ht); |
return ≺ |
} |
return NULL; |
} |
TASK finish_task() { |
#ifdef __NEW_TRACER__ |
//FTrace_OSD_init_udp(1,"192.168.82.43","192.168.82.205"); |
FTrace_OSD_init_udp(1, "192.168.82.205", "192.168.82.43"); |
FTrace_send_chunk(main_chunk, 0, FTRACE_CHUNK_FLAG_FREE | FTRACE_CHUNK_FLAG_CYC); |
exit(0); |
#else |
exit(0); |
#endif |
return NULL; |
} |
void end_simulation() { |
#ifdef __NEW_TRACER__ |
int i; |
struct loader_task *l = loader_task_list; |
NRT_TASK_MODEL nrt; |
TRACER_LOGEVENT(FTrace_EVT_trace_stop,0,0); |
FTrace_disable(); |
i = 0; |
while (i < total_loader_task) { |
group_kill(l->group); |
i++; |
l=&loader_task_list[i]; |
} |
nrt_task_default_model(nrt); |
task_activate(task_create("Finish",finish_task,&nrt,NULL)); |
#else |
exit(0); |
#endif |
} |
void set_simulation_time (struct timespec *total) { |
struct timespec end_time; |
ADDTIMESPEC(&zero_time,total,&end_time); |
kern_event_post(&end_time,(void *)((void *)(end_simulation)),NULL); |
} |
/* Set the zero_time and post the first activation event */ |
void start_simulation() { |
int i; |
struct loader_task *l = loader_task_list; |
struct timespec end_time; |
PISTAR_mutexattr_t a; |
PISTAR_mutexattr_default(a); |
i = 0; |
#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); |
TRACER_LOGEVENT(FTrace_EVT_trace_start,proc_table[exec_shadow].context,clk_per_msec); |
for (i=0;i<10;i++) |
if (proc_table[i].context != 0) TRACER_LOGEVENT(FTrace_EVT_id, |
(unsigned short int)proc_table[i].context,i); |
i = 0; |
kern_gettime(&zero_time); |
while (i < total_loader_task) { |
if (l->muxstatus == 1) { |
mutex_init(&mutex_table[l->resource],&a); |
l->muxstatus = 2; |
} |
if (l->act_number > 0) { |
ADDTIMESPEC(&zero_time, &l->act[0], &end_time); |
l->act_current++; |
kern_event_post(&end_time,(void *)((void *)(loader_task_activate)),l); |
} |
i++; |
l=&loader_task_list[i]; |
} |
} |
/* Activate task and post the new activation event */ |
void loader_task_activate(struct loader_task *l) { |
struct timespec actual_time,end_time; |
kern_gettime(&actual_time); |
group_activate(l->group); |
if (l->act_number > l->act_current) { |
ADDTIMESPEC(&actual_time, &l->act[l->act_current], &end_time); |
l->act_current++; |
kern_event_post(&end_time,(void *)((void *)(loader_task_activate)),l); |
} |
} |
/demos/trunk/loader/shark/func.h |
---|
0,0 → 1,112 |
#ifndef __FUNC_H__ |
#define __FUNC_H__ |
#include "kernel/kern.h" |
#include "fsf_basic_types.h" |
#include "fsf_core.h" |
#include "fsf_server.h" |
#include "shark.h" |
#define OS_SHARK |
#define get_current_exec_task() exec_shadow |
/* Return the PID/pthread_t of calling task */ |
#define generic_get_server_from_contract get_server_from_contract |
/* Return the server_id from the contract number used |
* inside .fsf file to define contract parameters |
* |
* generic_get_server_from_contract(int contract_number) */ |
#define generic_calibrate_cycle calibrate_cycle |
/* Set the calibration parameter "cal_cycle" |
* only if it's initialized to 0. The calibration routine |
* calculates cal_cycle from CALIBRATION_DELTA. |
* This step can also be performed outside the demo. |
* Inside calibrate.h you can set the calibration parameters |
* for calibration step performed outside. |
* |
* cal_cycle is the number of cycles that are needed to |
* make CALIBRATION_DELTA number of iteration. |
* |
* kern_cli(); |
* kern_gettime(&start); |
* for (i=0;i<CALIBRATION_DELTA;i++) |
* __asm__ __volatile__ ("xorl %%eax,%%eax\n\t" |
* "cpuid\n\t" |
* :::"eax","ebx","ecx","edx"); |
* kern_gettime(&end); |
* kern_sti(); |
* |
* SUBTIMESPEC(&end,&start,&diff); |
* cal_cycles = TIMESPEC2USEC(&diff); |
* |
*/ |
#define generic_set_next_activation set_next_activation |
/* Set the next activation time. It's like fsf_schedule_next_timed_job |
* but it don't return nothing |
*/ |
#define generic_set_simulation_time set_simulation_time |
/* Set the end time of simulation */ |
#define generic_get_task_model get_task_model |
/* Return a pointer to the struct that contains the |
* local shceduler parameter */ |
#define generic_start_simulation start_simulation |
/* Start the simulation */ |
#define generic_fsfinit() fsfinit() |
/* Create the fsf_server */ |
#define generic_task_endcycle() task_endcycle() |
/* The job is finished */ |
#define generic_end_simulation() exit(0) |
/* Exit from simulation */ |
#define printf cprintf |
/* Printf standard function */ |
/* Mutex */ |
extern __inline__ void generic_lock_mutex(int res) { |
extern mutex_t mutex_table[MAX_MUTEX]; |
mutex_lock(&mutex_table[res]); |
} |
extern __inline__ void generic_unlock_mutex(int res) { |
extern mutex_t mutex_table[MAX_MUTEX]; |
mutex_unlock(&mutex_table[res]); |
} |
/* TASK RUNTIME FUNCTIONS */ |
extern __inline__ void start_oneshot_task(void) {} |
extern __inline__ void end_oneshot_task(void) {} |
extern __inline__ void start_periodic_task(void) {} |
extern __inline__ void start_job_periodic_task(void) { |
task_testcancel(); |
} |
extern __inline__ void end_job_periodic_task(void) { |
task_testcancel(); |
} |
extern __inline__ void end_periodic_task(void) {} |
extern __inline__ void start_back_task(void) {} |
extern __inline__ void start_job_back_task(void) { |
task_testcancel(); |
} |
extern __inline__ void end_job_back_task(void) { |
task_testcancel(); |
} |
extern __inline__ void end_back_task(void) {} |
#endif |
/demos/trunk/loader/shark/shark.mak |
---|
0,0 → 1,13 |
ifndef BASE |
BASE=../../.. |
endif |
include $(BASE)/config/config.mk |
PROGS = TEST |
include $(BASE)/config/example.mk |
TEST: |
make -f $(SUBMAKE) APP="nload" BASE=../../.. INIT= OTHEROBJS="event.o initfile.o shark.o fsfinit.o" OTHERINCL="-I." SHARKOPT="__LINUXC26__ __PCI__ __NET__ __FIRST__" |
cp nload TEST |
/demos/trunk/loader/shark/shark.h |
---|
0,0 → 1,19 |
#ifndef __SHARK_H__ |
#define __SHARK_H__ |
#include "nload.h" |
#include "lconst.h" |
#define MAX_MUTEX 20 |
int calibrate_cycle(); |
void start_simulation(); |
void *get_task_model(struct loader_task *current); |
void set_simulation_time (struct timespec *total); |
void set_next_activation(struct timespec *next); |
void loader_task_activate(struct loader_task *l); |
int get_server_from_contract(int contract); |
void fsfinit(); |
#endif |
/demos/trunk/loader/shark/makefile.in |
---|
0,0 → 1,14 |
# |
# Shark dependecies |
# |
os_specific_dep: out/shark.done out/makefile |
out/shark.done: |
cd out; cp -sf ../shark/*.c . |
cd out; cp -sf ../shark/*.h . |
touch out/shark.done |
out/makefile: shark/shark.mak |
sed -e "s/TEST/$(TEST)/" shark/shark.mak > out/makefile |
/demos/trunk/loader/loadfile/loadr.fsf |
---|
0,0 → 1,72 |
# CONTRACT SECTION |
# |
# CONTRACT NUMBER:CMIN:TMAX:CMAX:TMIN:WORKLOAD:DEADLINE:LOCAL SCHEDULER |
# |
# YOU WILL HAVE A SERVER FOR EACH SPECIFIED CONTRACT, |
# SO IN THE TASK SECTION YOU CAN SPECIFY THE "CONTRACT NUMBER" |
# INSTEAD OF THE SERVER NUMBER, WHICH IS CALCULATED INSIDE THE |
# LOADER |
# |
# ALL THE TIME PARAMETERS INSIDE THIS FILE ARE ALWAYS EXPRESSED AS |
# "[SECONDS][MICROSECONDS]" TO AVOID FLOATING POINT CALCULATIONS |
# |
# WORKLOAD |
# 0 BOUNDED |
# 1 INDETERMINATED |
# |
# LOCAL SCHEDULER |
# NONE - DEFAULT FOR THE FRAMEWORK |
# POSIX |
# EDF |
# RM |
# |
# TASK SECTION |
# |
# TASK TYPE:CONTRACT NUMBER:LOCAL SCHEDULER:NUMBER OF TASK:DEADLINE:WCET:TASK ACT TYPE (PAR1,PAR2,...): |
# :TASK EXEC TYPE (PAR1,PAR2,...):CRITICAL SESSION (PAR1,PAR2,PAR3,PAR4); |
# |
# TASK TYPE |
# OS - ONE_SHOT |
# CT - CYCLICAL_TASK |
# BT - BACKGROUND_TASK |
# |
# TASK EXEC TYPE |
# EXEC_CONST(TIME) |
# - CONSTANT EXEC TIME |
# EXEC_MEAN(MEAN, DELTA) |
# - VARIABLE EXEC TIME WITH CONSTANT DISTRIBUTION |
# |
# TASK ACTIVATION TIME |
# ACT_SINGLE(START_TIME) |
# ACT_PERIODIC(START_TIME, PERIOD) |
# ACT_MEAN(START_TIME, MEAN, DELTA) |
# |
# CRITICAL SESSION |
# CRIT(RES NUMBER, BLOCKING_TIME) |
# NO_CRIT |
# |
TOTAL_EXEC_TIME:[20][0]; |
# SIMULATION TOTAL TIME |
CONTRACT SECTION |
[0]:[0][9000]:[0][30000]:[0][9000]:[0][30000]:[0]:[0][0]:EDF; |
[1]:[0][9000]:[0][30000]:[0][9000]:[0][30000]:[0]:[0][0]:EDF; |
[2]:[0][6000]:[0][60000]:[0][6000]:[0][60000]:[0]:[0][0]:POSIX; |
END |
TASK SECTION |
CT:[0]:EDF:[2]:[0][100000]:[0][40000]:ACT_PERIODIC([0][0],[0][100000]): |
:EXEC_MEAN([0][8000]:[0][14000]):NO_CRIT; |
CT:[1]:EDF:[2]:[0][100000]:[0][40000]:ACT_PERIODIC([0][0],[0][100000]): |
:EXEC_MEAN([0][8000]:[0][14000]):NO_CRIT; |
BT:[2]:POSIX:[2]:[0][0]:[0][0]:ACT_SINGLE([0][0]): |
:EXEC_CONST([0][10000]):NO_CRIT; |
END |
/demos/trunk/loader/loadfile/loadm.fsf |
---|
0,0 → 1,72 |
# CONTRACT SECTION |
# |
# CONTRACT NUMBER:CMIN:TMAX:CMAX:TMIN:WORKLOAD:DEADLINE:LOCAL SCHEDULER |
# |
# YOU WILL HAVE A SERVER FOR EACH SPECIFIED CONTRACT, |
# SO IN THE TASK SECTION YOU CAN SPECIFY THE "CONTRACT NUMBER" |
# INSTEAD OF THE SERVER NUMBER, WHICH IS CALCULATED INSIDE THE |
# LOADER |
# |
# ALL THE TIME PARAMETERS INSIDE THIS FILE ARE ALWAYS EXPRESSED AS |
# "[SECONDS][MICROSECONDS]" TO AVOID FLOATING POINT CALCULATIONS |
# |
# WORKLOAD |
# 0 BOUNDED |
# 1 INDETERMINATED |
# |
# LOCAL SCHEDULER |
# NONE - DEFAULT FOR THE FRAMEWORK |
# POSIX |
# EDF |
# RM |
# |
# TASK SECTION |
# |
# TASK TYPE:CONTRACT NUMBER:LOCAL SCHEDULER:NUMBER OF TASK:DEADLINE:WCET:TASK ACT TYPE (PAR1,PAR2,...): |
# :TASK EXEC TYPE (PAR1,PAR2,...):CRITICAL SESSION (PAR1,PAR2,PAR3,PAR4); |
# |
# TASK TYPE |
# OS - ONE_SHOT |
# CT - CYCLICAL_TASK |
# BT - BACKGROUND_TASK |
# |
# TASK EXEC TYPE |
# EXEC_CONST(TIME) |
# - CONSTANT EXEC TIME |
# EXEC_MEAN(MEAN, DELTA) |
# - VARIABLE EXEC TIME WITH CONSTANT DISTRIBUTION |
# |
# TASK ACTIVATION TIME |
# ACT_SINGLE(START_TIME) |
# ACT_PERIODIC(START_TIME, PERIOD) |
# ACT_MEAN(START_TIME, MEAN, DELTA) |
# |
# CRITICAL SESSION |
# CRIT(RES NUMBER, BLOCKING_TIME) |
# NO_CRIT |
# |
TOTAL_EXEC_TIME:[20][0]; |
# SIMULATION TOTAL TIME |
CONTRACT SECTION |
[0]:[0][6000]:[0][30000]:[0][6000]:[0][30000]:[0]:[0][0]:EDF; |
[1]:[0][6000]:[0][60000]:[0][6000]:[0][60000]:[0]:[0][0]:EDF; |
[2]:[0][12000]:[0][60000]:[0][12000]:[0][60000]:[0]:[0][0]:POSIX; |
END |
TASK SECTION |
CT:[0]:EDF:[2]:[1][0]:[0][40000]:ACT_PERIODIC([1][0],[1][0]): |
:EXEC_CONST([0][16000]):CRIT([0],[0][2000]); |
CT:[1]:EDF:[2]:[1][0]:[0][40000]:ACT_PERIODIC([2][0],[1][0]): |
:EXEC_MEAN([0][16000],[0][10000]):CRIT([0],[0][2000]); |
BT:[2]:POSIX:[2]:[0][0]:[0][0]:ACT_SINGLE([3][0]): |
:EXEC_CONST([0][10000]):CRIT([0],[0][2000]); |
END |
/demos/trunk/loader/loadfile/load.fsf |
---|
0,0 → 1,76 |
# CONTRACT SECTION |
# |
# CONTRACT NUMBER:CMIN:TMAX:CMAX:TMIN:WORKLOAD:DEADLINE:LOCAL SCHEDULER |
# |
# YOU WILL HAVE A SERVER FOR EACH SPECIFIED CONTRACT, |
# SO IN THE TASK SECTION YOU CAN SPECIFY THE "CONTRACT NUMBER" |
# INSTEAD OF THE SERVER NUMBER, WHICH IS CALCULATED INSIDE THE |
# LOADER |
# |
# ALL THE TIME PARAMETERS INSIDE THIS FILE ARE ALWAYS EXPRESSED AS |
# "[SECONDS][MICROSECONDS]" TO AVOID FLOATING POINT CALCULATIONS |
# |
# WORKLOAD |
# 0 BOUNDED |
# 1 INDETERMINATED |
# |
# LOCAL SCHEDULER |
# POSIX |
# EDF |
# RM |
# NONE DEFAULT FROM THE FRAMEWORK |
# |
# TASK SECTION |
# |
# TASK TYPE:CONTRACT NUMBER:LOCAL SCHEDULER:NUMBER OF TASK:DEADLINE:WCET:TASK ACT TYPE (PAR1,PAR2,...): |
# :TASK EXEC TYPE (PAR1,PAR2,...):CRITICAL SESSION (PAR1,PAR2,PAR3,PAR4); |
# |
# TASK TYPE |
# OS - ONE_SHOT |
# CT - CYCLICAL_TASK |
# BT - BACKGROUND_TASK |
# |
# TASK EXEC TYPE |
# EXEC_CONST(TIME) |
# - CONSTANT EXEC TIME |
# EXEC_MEAN(MEAN, DELTA) |
# - VARIABLE EXEC TIME WITH CONSTANT DISTRIBUTION |
# |
# TASK ACTIVATION TIME |
# ACT_SINGLE(START_TIME) |
# ACT_PERIODIC(START_TIME, PERIOD) |
# ACT_MEAN(START_TIME, MEAN, DELTA) |
# |
# CRITICAL SESSION |
# CRIT(RES NUMBER, BLOCKING_TIME) |
# NO_CRIT |
# |
TOTAL_EXEC_TIME:[20][0]; |
# SIMULATION TOTAL TIME |
CONTRACT SECTION |
[0]:[0][3000]:[0][10000]:[0][3000]:[0][10000]:[0]:[0][9000]:POSIX; |
[1]:[0][6000]:[0][30000]:[0][6000]:[0][30000]:[0]:[0][0]:POSIX; |
[2]:[0][3000]:[0][30000]:[0][3000]:[0][30000]:[0]:[0][0]:POSIX; |
[3]:[0][3000]:[0][20000]:[0][3000]:[0][20000]:[0]:[0][0]:POSIX; |
END |
TASK SECTION |
BT:[0]:POSIX:[1]:[0][0]:[0][0]:ACT_SINGLE([1][0]): |
:EXEC_CONST([0][25000]):NO_CRIT; |
BT:[1]:POSIX:[1]:[0][0]:[0][0]:ACT_SINGLE([2][0]): |
:EXEC_CONST([0][16000]):NO_CRIT; |
OS:[2]:POSIX:[1]:[0][0]:[0][0]:ACT_SINGLE([3][0]): |
:EXEC_CONST([1][0]):NO_CRIT; |
BT:[3]:POSIX:[5]:[0][0]:[0][0]:ACT_SINGLE([4][0]): |
:EXEC_CONST([0][10000]):NO_CRIT; |
END |
/demos/trunk/loader/loadfile/loadxml.fsf2 |
---|
0,0 → 1,59 |
<?xml version="1.0" encoding="UTF-8"?> |
<fsf_framework xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../generators/java/fsf-schema.xsd"> |
<simulation> |
<time>20s 0u</time> |
</simulation> |
<contract> |
<cmin>0s 3000u</cmin> |
<tmax>0s 10000u</tmax> |
<cmax>0s 3000u</cmax> |
<tmin>0s 10000u</tmin> |
<workload>0</workload> |
<localscheduler type="POSIX"> |
<task_section type="BackTask"> |
<number>1</number> |
<act_section> |
<start_time>3s 0u</start_time> |
</act_section> |
<exec_section> |
<exec_time>3s 0u</exec_time> |
</exec_section> |
</task_section> |
<task_section type="OneShot"> |
<number>2</number> |
<dline>0s 0u</dline> |
<wcet>0s 0u</wcet> |
<act_section> |
<start_time>3s 0u</start_time> |
</act_section> |
<exec_section> |
<exec_time>3s 0u</exec_time> |
</exec_section> |
</task_section> |
</localscheduler> |
</contract> |
<contract> |
<cmin>0s 3000u</cmin> |
<tmax>0s 10000u</tmax> |
<cmax>0s 3000u</cmax> |
<tmin>0s 10000u</tmin> |
<workload>0</workload> |
<localscheduler type="EDF"> |
<task_section type="CyclicalTask"> |
<number>1</number> |
<dline>1s 0u</dline> |
<wcet>0s 100000u</wcet> |
<act_section> |
<start_time>3s 0u</start_time> |
<period_time>1s 0u</period_time> |
</act_section> |
<exec_section> |
<exec_time>0s 10000u</exec_time> |
<delta_time>0s 10000u</delta_time> |
</exec_section> |
</task_section> |
</localscheduler> |
</contract> |
</fsf_framework> |
/demos/trunk/loader/generators/lparser.c |
---|
0,0 → 1,486 |
#include <stdlib.h> |
#include <string.h> |
#include <stdio.h> |
#include "lparser.h" |
#include "common/time.h" |
#define PARSER_DEBUG |
static int find_break(char **buf, int find_type, struct timespec *time, int *val) |
{ |
int i; |
char str[20]; |
i = 0; |
while (((char *)(*buf))[i] == ' ' || ((char *)(*buf))[i] == ':' || |
((char *)(*buf))[i] == '\n' || ((char *)(*buf))[i] == '\r') i++; |
*buf += i; |
if (!strncmp(*buf,"END",3) && find_type == PAR_NOTHING) { |
*buf += 3; |
return PAR_END; |
} |
if (!strncmp(*buf,"CONTRACT SECTION",16) && find_type == PAR_NOTHING) { |
*buf += 16; |
return PAR_CONTRACT_SECTION; |
} |
if (!strncmp(*buf,"TASK SECTION",12) && find_type == PAR_NOTHING) { |
*buf += 12; |
return PAR_TASK_SECTION; |
} |
i = 0; |
if (((char *)(*buf))[0] == '#' && find_type == PAR_NOTHING) { |
while (((char *)(*buf))[i] != '\n' && ((char *)(*buf))[i] != '\r') i++; |
*buf += i; |
return PAR_FOUND; |
} |
switch (find_type) { |
case PAR_NOTHING: |
if (((char *)(*buf))[0] == ';' || |
((char *)(*buf))[0] < 32) { |
*buf += 1; |
return PAR_FOUND; |
} |
break; |
case PAR_TOTAL_EXEC_TIME: |
if (!strncmp(*buf, "TOTAL_EXEC_TIME:",16)) { |
*buf += 16; |
return PAR_FOUND; |
} |
break; |
case PAR_TIME: |
if (((char *)(*buf))[0] != '[') return PAR_ERROR; |
*buf += 1; |
i = 0; |
while (((char *)(*buf))[i] >= '0' && ((char *)(*buf))[i] <= '9') { |
str[i] = ((char *)(*buf))[i]; |
i++; |
} |
if (((char *)(*buf))[i] != ']') return PAR_ERROR; |
str[i] = 0; |
time->tv_sec = atoi(str); |
i += 2; |
*buf += i; |
i = 0; |
while (((char *)(*buf))[i] >= '0' && ((char *)(*buf))[i] <= '9') { |
str[i] = ((char *)(*buf))[i]; |
i++; |
} |
if (((char *)(*buf))[i] != ']') return PAR_ERROR; |
str[i] = 0; |
time->tv_nsec = atoi(str) * 1000; |
i += 2; |
*buf += i; |
return PAR_FOUND; |
break; |
case PAR_TASK_TYPE: |
if (!strncmp(*buf, "OS:",3)) { |
*val = PAR_TASK_OS; |
*buf += 3; |
return PAR_FOUND; |
} |
if (!strncmp(*buf, "CT:",3)) { |
*val = PAR_TASK_CT; |
*buf += 3; |
return PAR_FOUND; |
} |
if (!strncmp(*buf, "BT:",3)) { |
*val = PAR_TASK_BT; |
*buf += 3; |
return PAR_FOUND; |
} |
break; |
case PAR_TASK_NUMBER: |
if (((char *)(*buf))[0] != '[') return PAR_ERROR; |
*buf += 1; |
i = 0; |
while (((char *)(*buf))[i] >= '0' && ((char *)(*buf))[i] <= '9') { |
str[i] = ((char *)(*buf))[i]; |
i++; |
} |
if (((char *)(*buf))[i] != ']') return PAR_ERROR; |
str[i] = 0; |
*val = atoi(str); |
i += 2; |
*buf += i; |
return PAR_FOUND; |
break; |
case PAR_ACT_TYPE: |
if (!strncmp(*buf,"ACT_SINGLE(",11)) { |
*buf += 11; |
*val = PAR_ACT_SINGLE; |
return PAR_FOUND; |
} |
if (!strncmp(*buf,"ACT_PERIODIC(",13)) { |
*buf += 13; |
*val = PAR_ACT_PERIODIC; |
return PAR_FOUND; |
} |
if (!strncmp(*buf,"ACT_MEAN(",9)) { |
*buf += 9; |
*val = PAR_ACT_MEAN; |
return PAR_FOUND; |
} |
return PAR_ERROR; |
break; |
case PAR_LOCAL_SCHEDULER: |
if (!strncmp(*buf,"POSIX",5)) { |
*buf += 5; |
*val = PAR_POSIX; |
return PAR_FOUND; |
} |
if (!strncmp(*buf,"EDF",3)) { |
*buf += 3; |
*val = PAR_EDF; |
return PAR_FOUND; |
} |
if (!strncmp(*buf,"RM",2)) { |
*buf += 2; |
*val = PAR_RM; |
return PAR_FOUND; |
} |
if (!strncmp(*buf,"NONE",2)) { |
*buf += 4; |
*val = PAR_NONE; |
return PAR_FOUND; |
} |
return PAR_ERROR; |
break; |
case PAR_EXEC_TYPE: |
if (!strncmp(*buf,"EXEC_CONST(",11)) { |
*buf += 11; |
*val = PAR_EXEC_CONST; |
return PAR_FOUND; |
} |
if (!strncmp(*buf,"EXEC_MEAN(",10)) { |
*buf += 10; |
*val = PAR_EXEC_MEAN; |
return PAR_FOUND; |
} |
return PAR_ERROR; |
break; |
case PAR_CRIT_SESSION: |
if (!strncmp(*buf,"NO_CRIT",7)) { |
*buf += 7; |
*val = PAR_NO_CRIT; |
return PAR_FOUND; |
} |
if (!strncmp(*buf,"CRIT(",5)) { |
*buf += 5; |
*val = PAR_CRIT; |
return PAR_FOUND; |
} |
return PAR_ERROR; |
break; |
} |
return PAR_ERROR; |
} |
void par_error(int line_num) |
{ |
printf("\nParser error: line [%d]\n",line_num); |
exit(1); |
} |
/* result: |
* 0 -> nothing |
* 1 -> total |
* 2 -> new task-loader |
* 3 -> end file |
*/ |
int line_parser_task(char **pbuf, int line_num, struct loader_task **last) |
{ |
struct timespec time; |
struct loader_task *ld = NULL; |
int val, res; |
res = find_break(pbuf, PAR_NOTHING, &time, &val); |
if (res == PAR_FOUND) return 0; |
if (res == PAR_END) return 3; |
res = find_break(pbuf,PAR_TASK_TYPE, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("TASK TYPE = %d\n",val); |
#endif |
ld = malloc(sizeof(struct loader_task)); |
if (ld == NULL) par_error(line_num); |
ld->next = NULL; |
*last = ld; |
ld->task_type = val; |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TASK_NUMBER, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("TASK SERVER = %d\n",val); |
#endif |
ld->server = val; |
} else par_error(line_num); |
res = find_break(pbuf,PAR_LOCAL_SCHEDULER, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("TASK LOCAL SCHEDULER = %d\n",val); |
#endif |
ld->local_scheduler = val; |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TASK_NUMBER, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("TASK NUMBER = %d\n",val); |
#endif |
ld->number = val; |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("DEADLINE: [%ld][%ld]\n",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->deadline,&time); |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("WCET: [%ld][%ld]\n",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->wcet,&time); |
} else par_error(line_num); |
res = find_break(pbuf,PAR_ACT_TYPE, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("ACTIVATION TYPE: %d (",val); |
#endif |
ld->act_type = val; |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->act_par_1,&time); |
} else par_error(line_num); |
if (ld->act_type != PAR_ACT_SINGLE) { |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->act_par_2,&time); |
} else par_error(line_num); |
} |
if (ld->act_type != PAR_ACT_SINGLE && ld->act_type != PAR_ACT_PERIODIC) { |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->act_par_3,&time); |
} else par_error(line_num); |
} |
#ifdef PARSER_DEBUG |
printf(")\n"); |
#endif |
} else par_error(line_num); |
res = find_break(pbuf,PAR_EXEC_TYPE, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("EXEC TYPE: %d (",val); |
#endif |
ld->exec_type = val; |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->exec_par_1,&time); |
} else par_error(line_num); |
if (ld->exec_type != PAR_EXEC_CONST) { |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->exec_par_2,&time); |
} else par_error(line_num); |
} |
#ifdef PARSER_DEBUG |
printf(")\n"); |
#endif |
} else par_error(line_num); |
res = find_break(pbuf,PAR_CRIT_SESSION, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("CRITITCAL SESSION: %d (",val); |
#endif |
ld->crit_type = val; |
if (ld->crit_type == PAR_CRIT) { |
res = find_break(pbuf,PAR_TASK_NUMBER, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("[%d]",val); |
#endif |
ld->resource = val; |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&ld->crit_par,&time); |
} else par_error(line_num); |
} |
#ifdef PARSER_DEBUG |
printf(")\n"); |
#endif |
} else par_error(line_num); |
return 2; |
} |
int line_parser_contract(char **pbuf, int line_num, struct timespec *total, struct loader_contract **last) |
{ |
struct timespec time; |
struct loader_contract *lc = NULL; |
int val, res; |
res = find_break(pbuf, PAR_NOTHING, &time, &val); |
if (res == PAR_FOUND) return 0; |
if (res == PAR_END) return 3; |
res = find_break(pbuf,PAR_TOTAL_EXEC_TIME, &time, &val); |
if (res == PAR_FOUND) { |
NULL_TIMESPEC(total); |
res = find_break(pbuf, PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
TIMESPEC_ASSIGN(total,&time); |
#ifdef PARSER_DEBUG |
printf("TOTAL EXEC TIME SEC = %ld NSEC = %ld\n",total->tv_sec,total->tv_nsec); |
#endif |
return 1; |
} else par_error(line_num); |
} |
res = find_break(pbuf,PAR_TASK_NUMBER, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("CONTRACT [%d]",val); |
#endif |
lc = malloc(sizeof(struct loader_contract)); |
if (lc == NULL) par_error(line_num); |
lc->next = NULL; |
*last = lc; |
lc->number = val; |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&lc->cmin,&time); |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&lc->tmax,&time); |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld]",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&lc->cmax,&time); |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld],",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&lc->tmin,&time); |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TASK_NUMBER, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%d]\n",val); |
#endif |
lc->workload = val; |
} else par_error(line_num); |
res = find_break(pbuf,PAR_TIME, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf(",[%ld][%ld],",time.tv_sec,time.tv_nsec/1000); |
#endif |
TIMESPEC_ASSIGN(&lc->deadline,&time); |
} else par_error(line_num); |
res = find_break(pbuf,PAR_LOCAL_SCHEDULER, &time, &val); |
if (res == PAR_FOUND) { |
#ifdef PARSER_DEBUG |
printf("LOCAL SCHEDULER = %d\n",val); |
#endif |
lc->local_scheduler = val; |
} else par_error(line_num); |
return 2; |
} |
/demos/trunk/loader/generators/event_gen.c |
---|
0,0 → 1,474 |
/* Event Generator |
* |
* Giacomo Guidi |
*/ |
#include <stdio.h> |
#include <stdlib.h> |
#include "lparser.h" |
#include "lread.h" |
#include "time.h" |
#include "common/time.h" |
#define LOADFILE_DIR "../loadfile/" |
#define EVENT_DEFINE "event.c" |
#define ACT_LIST "event.c" |
int write_struct(void) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"w"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header, "\n#include \"func.h\"\n"); |
fclose(file_event_header); |
return 0; |
} |
int write_basic_par_start(void) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header, "struct loader_task loader_task_list[] = {\n"); |
fclose(file_event_header); |
return 0; |
} |
int write_contract_start(void) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header, "struct loader_contract loader_contract_list[] = {\n"); |
fclose(file_event_header); |
return 0; |
} |
int write_basic_par(struct loader_task *c) |
{ |
FILE *file_event_header; |
int muxpres; |
char muxtemp[30]; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
if (c->crit_type == PAR_CRIT) { |
muxpres = 1; |
sprintf(muxtemp,"block_%s",c->name); |
} else { |
muxpres = 0; |
sprintf(muxtemp,"NULL"); |
} |
fprintf(file_event_header, " {\"%s\",%d,%d,%d,%d,%d,{%d,%d},{%d,%d},%d,0,%d,%d,act_%s,exec_%s,%s},\n", |
c->name,(int)c->task_type,(int)c->server,(int)c->local_scheduler,(int)c->number,(int)c->group, |
(int)c->deadline.tv_sec, (int)c->deadline.tv_nsec, |
(int)c->wcet.tv_sec, (int)c->wcet.tv_nsec, |
(int)c->act_number, (int)c->resource, muxpres, c->name, c->name, muxtemp); |
fclose(file_event_header); |
return 0; |
} |
int write_contract(struct loader_contract *c) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header, " {%d,{%d,%d},{%d,%d},{%d,%d},{%d,%d},%d,{%d,%d},%d,-1},\n", |
(int)c->number,(int)c->cmin.tv_sec,(int)c->cmin.tv_nsec, |
(int)c->tmax.tv_sec,(int)c->tmax.tv_nsec, |
(int)c->cmax.tv_sec,(int)c->cmax.tv_nsec, |
(int)c->tmin.tv_sec,(int)c->tmin.tv_nsec, |
(int)c->workload, |
(int)c->deadline.tv_sec,(int)c->deadline.tv_nsec, |
(int)c->local_scheduler); |
fclose(file_event_header); |
return 0; |
} |
int close_loader_task(int total_task_number) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header,"};\n\n"); |
fprintf(file_event_header,"int total_loader_task = %d;\n\n",total_task_number); |
fclose(file_event_header); |
return 0; |
} |
int close_loader_contract(int total_contract_number) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header,"};\n\n"); |
fprintf(file_event_header,"int total_loader_contract = %d;\n\n",total_contract_number); |
fclose(file_event_header); |
return 0; |
} |
int write_simulation_time(struct timespec *total) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header,"struct timespec total_time = {%d,%d};\n\n",(int)total->tv_sec,(int)total->tv_nsec); |
fclose(file_event_header); |
return 0; |
} |
int write_single_act(struct timespec *t, struct loader_task *c) |
{ |
FILE *file_act_header; |
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
if (TIMESPEC_A_GT_B(t,&c->act_par_1)) { |
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d}};\n\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
c->act_number = 1; |
} else { |
fprintf(file_act_header,"struct timespec act_%s[] = {{0,0}};\n\n",c->name); |
c->act_number = 0; |
} |
fclose(file_act_header); |
return 0; |
} |
int write_periodic_act(struct timespec *t, struct loader_task *c) |
{ |
FILE *file_act_header; |
struct timespec tot_time; |
int period; |
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
c->act_number = 1; |
TIMESPEC_ASSIGN(&tot_time,&c->act_par_1); |
period = TIMESPEC2USEC(&c->act_par_2); |
while (TIMESPEC_A_GT_B(t, &tot_time)) { |
c->act_number++; |
ADDUSEC2TIMESPEC(period,&tot_time); |
fprintf(file_act_header," {%d,%d},\n", |
(int)c->act_par_2.tv_sec,(int)c->act_par_2.tv_nsec); |
} |
fprintf(file_act_header," };\n\n"); |
fclose(file_act_header); |
return 0; |
} |
int write_mean_act(struct timespec *t,struct loader_task *c) |
{ |
FILE *file_act_header; |
struct timespec tot_time; |
int next_act; |
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
c->act_number = 1; |
TIMESPEC_ASSIGN(&tot_time,&c->act_par_1); |
while (TIMESPEC_A_GT_B(t, &tot_time)) { |
c->act_number++; |
next_act = TIMESPEC2USEC(&c->act_par_2) + random() % TIMESPEC2USEC(&c->act_par_3) - TIMESPEC2USEC(&c->act_par_3) / 2; |
ADDUSEC2TIMESPEC(next_act,&tot_time); |
fprintf(file_act_header," {%d,%d},\n", |
next_act / 1000000, next_act % 1000000 * 1000); |
} |
fprintf(file_act_header," };\n\n"); |
fclose(file_act_header); |
return 0; |
} |
int write_block_const(struct loader_task *c) |
{ |
FILE *file_block_header; |
int i; |
file_block_header = fopen(ACT_LIST,"a+"); |
if (file_block_header == NULL) return 1; |
fprintf(file_block_header,"struct timespec block_%s[] = {{%d,%d},\n",c->name, |
(int)c->crit_par.tv_sec,(int)c->crit_par.tv_nsec); |
for (i=0; i< c->act_number-1; i++) |
fprintf(file_block_header," {%d,%d},\n", |
(int)c->crit_par.tv_sec,(int)c->crit_par.tv_nsec); |
fprintf(file_block_header," };\n\n"); |
fclose(file_block_header); |
return 0; |
} |
int write_exec_const(struct loader_task *c) |
{ |
FILE *file_exec_header; |
int i; |
file_exec_header = fopen(ACT_LIST,"a+"); |
if (file_exec_header == NULL) return 1; |
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",c->name, |
(int)c->exec_par_1.tv_sec,(int)c->exec_par_1.tv_nsec); |
for (i=0; i< c->act_number-1; i++) |
fprintf(file_exec_header," {%d,%d},\n", |
(int)c->exec_par_1.tv_sec,(int)c->exec_par_1.tv_nsec); |
fprintf(file_exec_header," };\n\n"); |
fclose(file_exec_header); |
return 0; |
} |
int write_exec_mean(struct loader_task *c) |
{ |
FILE *file_exec_header; |
int exec_time_usec; |
int i; |
file_exec_header = fopen(ACT_LIST,"a+"); |
if (file_exec_header == NULL) return 1; |
exec_time_usec = TIMESPEC2USEC(&c->exec_par_1) |
+ random() % TIMESPEC2USEC(&c->exec_par_2) - TIMESPEC2USEC(&c->exec_par_2) / 2; |
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",c->name, |
exec_time_usec / 1000000, exec_time_usec % 1000000 * 1000); |
for (i=0; i< c->act_number-1; i++) { |
exec_time_usec = TIMESPEC2USEC(&c->exec_par_1) |
+ random() % TIMESPEC2USEC(&c->exec_par_2) - TIMESPEC2USEC(&c->exec_par_2) / 2; |
fprintf(file_exec_header," {%d,%d},\n", |
exec_time_usec / 1000000, exec_time_usec % 1000000 * 1000); |
} |
fprintf(file_exec_header," };\n\n"); |
fclose(file_exec_header); |
return 0; |
} |
void *start; |
void *end; |
int main(int argc, char **argv) { |
char loadfile[100]; |
struct timespec total_time; |
struct loader_task *start_loader_task = NULL, *current_t; |
struct loader_contract *start_loader_contract = NULL, *current_c; |
int err,ldnum; |
int total_task_number; |
int total_contract_number; |
printf("\nEvent Generator\n"); |
if (argc < 2) { |
printf("Error: event_gen loadfile.fsf\n"); |
exit(1); |
} |
printf("Read loader file %s\n",argv[1]); |
sprintf(loadfile,"%s%s",LOADFILE_DIR,argv[1]); |
err = dos_preload(loadfile,100000,&start,&end); |
if (err != 0) { |
printf("Error: File not found\n"); |
exit(1); |
} |
printf("Parsing file\n"); |
line_reader(start, end, &total_time, &start_loader_task, &start_loader_contract); |
srandom(time(NULL)); |
write_struct(); |
current_t = start_loader_task; |
ldnum = 1; |
while(current_t != NULL) { |
sprintf(current_t->name,"ltask%d",ldnum); |
current_t->group = ldnum; |
ldnum++; |
switch (current_t->act_type) { |
case PAR_ACT_SINGLE: |
err = write_single_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
case PAR_ACT_PERIODIC: |
err = write_periodic_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
case PAR_ACT_MEAN: |
err = write_mean_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
} |
switch (current_t->exec_type) { |
case PAR_EXEC_CONST: |
err = write_exec_const(current_t); |
if (err != 0) { |
printf("Error writing exec header\n"); |
exit(1); |
} |
break; |
case PAR_EXEC_MEAN: |
err = write_exec_mean(current_t); |
if (err != 0) { |
printf("Error writing exec header\n"); |
exit(1); |
} |
break; |
} |
switch (current_t->crit_type) { |
case PAR_CRIT: |
err = write_block_const(current_t); |
if (err != 0) { |
printf("Error writing block header\n"); |
exit(1); |
} |
break; |
} |
current_t = current_t->next; |
} |
write_basic_par_start(); |
total_task_number = 0; |
current_t = start_loader_task; |
while(current_t != NULL) { |
write_basic_par(current_t); |
current_t = current_t->next; |
total_task_number++; |
} |
close_loader_task(total_task_number); |
write_contract_start(); |
total_contract_number = 0; |
current_c = start_loader_contract; |
while(current_c != NULL) { |
write_contract(current_c); |
current_c = current_c->next; |
total_contract_number++; |
} |
close_loader_contract(total_contract_number); |
write_simulation_time(&total_time); |
return 0; |
} |
/demos/trunk/loader/generators/lparser.h |
---|
0,0 → 1,58 |
#ifndef __LPARSER_H__ |
#define __LPARSER_H__ |
#include "common/lconst.h" |
struct loader_task { |
char name[20]; |
int number; |
int group; |
int server; |
int local_scheduler; |
int task_type; |
int act_type; |
struct timespec act_par_1; |
struct timespec act_par_2; |
struct timespec act_par_3; |
int exec_type; |
struct timespec exec_par_1; |
struct timespec exec_par_2; |
struct timespec deadline; |
struct timespec wcet; |
int act_number; |
struct timespec *act; |
struct timespec *exec; |
int crit_type; |
int resource; |
struct timespec crit_par; |
struct loader_task *next; |
}; |
struct loader_contract { |
int number; |
struct timespec cmin; |
struct timespec tmax; |
struct timespec cmax; |
struct timespec tmin; |
int workload; |
struct timespec deadline; |
int local_scheduler; |
struct loader_contract *next; |
}; |
int line_parser_contract(char **buf, int line_num, struct timespec *total_time, struct loader_contract **last); |
int line_parser_task(char **buf, int line_num, struct loader_task **last); |
#endif |
/demos/trunk/loader/generators/java/Application.java |
---|
0,0 → 1,856 |
//package first_filter; |
import java.io.*; |
import java.net.*; |
import java.util.List; |
import java.util.ArrayList; |
import java.util.Iterator; |
import org.jdom.*; |
import org.jdom.input.SAXBuilder; |
import org.jdom.output.XMLOutputter; |
import java.util.regex.*; |
import java.util.Random; |
/** |
* <p>Title: First XML filter</p> |
* <p>Description: </p> |
* <p>Copyright: Copyright (c) 2003</p> |
* <p>Company: Retis Lab</p> |
* @author not attributable |
* @version 1.0 |
*/ |
public class Application { |
private int numElements = 0; |
final String LOADFILE_DIR="../loadfile/"; |
final String EVENT_DEFINE="event.c"; |
final String ACT_LIST="event.c"; |
private int servernumber=0; |
private timespec simulation_time=new timespec(); |
ArrayList local_scheduler=new ArrayList(); |
ArrayList Task_Section=new ArrayList(); |
private int task_group=0; |
private int task_server=0; |
private int current_scheduler=0; |
//Construct the frame |
public Application() { |
try { |
jbInit(); |
} |
catch(Exception e) { |
e.printStackTrace(); |
} |
} |
//Component initialization |
private void jbInit() throws Exception { |
} |
public void process (String url) throws MalformedURLException { |
try { |
// Use SAXBuilder |
SAXBuilder builder = new SAXBuilder("org.apache.xerces.parsers.SAXParser", true); |
builder.setFeature("http://apache.org/xml/features/validation/schema", true); |
Document doc = builder.build(url); |
Element root = doc.getRootElement(); |
try { |
// Funzione per il salvataggio del file XML |
OutputStream fout = new FileOutputStream(EVENT_DEFINE); |
OutputStream bout = new BufferedOutputStream(fout); |
OutputStreamWriter out = new OutputStreamWriter(bout, "8859_1"); |
out.write("\n#include \"func.h\"\n"); |
processElement (root,out); |
out.flush(); |
out.close(); |
} catch (UnsupportedEncodingException e) { |
System.out.println("Non sono supportati i caratteri latini"); |
System.exit(1); |
} catch (IOException e){ |
System.out.println("Salvatagio fallito"); |
System.exit(1); |
} |
System.out.println ("Total Number of Elements Processed: " |
+numElements); |
} catch (JDOMException e) { |
System.out.println ("JDOM Exception: "+e.getMessage()); |
} catch (java.io.IOException e) { |
System.out.println ("File Exception: "+e.getMessage()); |
} |
} |
// Recursive Function to Process Elements |
// Prints the Element Name and keeps a running count |
// out total number of elements. |
private void processElement(Element element, OutputStreamWriter out) { |
numElements++; |
String elementName = element.getName(); |
System.out.println(elementName); |
List servers = element.getChildren(); |
Iterator iterator = servers.iterator(); |
/* get simulation parameter */ |
Element SimulationInfo = (Element) iterator.next(); |
Pattern pattern = Pattern.compile("[us\\s]+"); |
try { |
/*simulation time */ |
String[] stime = pattern.split(SimulationInfo.getChild("time").getText()); |
out.write("struct timespec total_time={" + stime[0] + "," + stime[1] + |
"};\n\n"); |
simulation_time.tv_sec = Long.valueOf(stime[0].trim()).longValue(); |
simulation_time.tv_nsec = Long.valueOf(stime[1].trim()).longValue() / |
1000; |
//float f = Float.valueOf(s.trim()).floatValue(); |
/* server section start */ |
out.write("struct loader_contract loader_contract_list[] = {\n"); |
int total_server=0; |
while (iterator.hasNext()) { |
/* get server */ |
Element server = (Element) iterator.next(); |
process_server_section(server, out); |
total_server++; |
} |
out.write("};\n\n"); |
out.write("int total_loader_contract="+total_server+";\n\n"); |
iterator = local_scheduler.iterator(); |
while (iterator.hasNext()) { |
/* get server */ |
Element loc_sched = (Element) iterator.next(); |
process_scheduler_section(loc_sched, out); |
task_server++; |
} |
iterator = Task_Section.iterator(); |
int total_task_section=0; |
out.write("\nstruct loader_task loader_task_list[] = {\n"); |
while (iterator.hasNext()) { |
/* get server */ |
task_class tsk_sec = (task_class) iterator.next(); |
out.write(" {\"" + tsk_sec.name + "\"," + tsk_sec.task_type + "," + |
tsk_sec.contract + |
"," + tsk_sec.localscheduler + "," + tsk_sec.number + "," |
+ tsk_sec.group + ",{" + tsk_sec.deadline.tv_sec + |
"," + |
tsk_sec.deadline.tv_nsec + "}," + "{" + |
tsk_sec.wcet.tv_sec + "," + |
tsk_sec.wcet.tv_nsec + "}," + tsk_sec.act_number + |
",0,act_" + tsk_sec.name + |
",exec_" + tsk_sec.name + "},\n"); |
total_task_section++; |
} |
out.write("};\n\n"); |
out.write("int total_loader_task="+total_task_section+";\n\n"); |
} |
catch (java.io.IOException e) { |
System.out.println("File Exception: " + e.getMessage()); |
} |
} |
void process_scheduler_section(Element e, OutputStreamWriter out) { |
Attribute t; |
t=e.getAttribute("type"); |
List localpars = e.getChildren(); |
Iterator iterator = localpars.iterator(); |
while (iterator.hasNext()) { |
/* get task section */ |
Element loc_task = (Element) iterator.next(); |
process_task_section(loc_task, out, t); |
} |
} |
void process_task_section(Element e, OutputStreamWriter out, Attribute loc) { |
Attribute t; |
int act; |
act=1; |
int task_type=0; |
int localscheduler=0; |
timespec time = new timespec(); |
Pattern pattern = Pattern.compile("[us\\s]+"); |
String scheduler=loc.getValue(); |
if (scheduler.equals("POSIX")) { |
localscheduler=30; |
} |
else if (scheduler.equals("EDF")) { |
localscheduler=31; |
} |
else if (scheduler.equals("RM")) { |
localscheduler=32; |
} |
/* get task section */ |
t=e.getAttribute("type"); |
if (t.getValue().equals("BackTask")) { |
process_back_task(e, out); |
task_type=23; |
} else if (t.getValue().equals("OneShot")) { |
process_oneshot_task(e, out); |
task_type=21; |
} else if (t.getValue().equals("CyclicalTask")) { |
task_type=22; |
act=process_cyclical_task(e, out); |
} |
task_class section=new task_class(); |
section.deadline=new timespec(); |
section.wcet=new timespec(); |
section.name="task"+task_group; |
section.contract=task_server; |
section.group=task_group; |
section.act_number=act; |
section.task_type=task_type; |
section.localscheduler=localscheduler; |
section.number=Integer.valueOf(e.getChild("number").getText()).intValue(); |
Element dl = e.getChild("dline"); |
if (dl != null) { |
String[] dline=pattern.split(dl.getText()); |
time.tv_sec = Long.valueOf(dline[0]).longValue(); |
time.tv_nsec = Long.valueOf(dline[1]).longValue() * 1000; |
section.deadline.tv_sec=time.tv_sec; |
section.deadline.tv_nsec=time.tv_nsec; |
} |
Element wc = e.getChild("wcet"); |
if (wc != null) { |
String[] wcet=pattern.split(e.getChild("wcet").getText()); |
time.tv_sec = Long.valueOf(wcet[0]).longValue(); |
time.tv_nsec = Long.valueOf(wcet[1]).longValue() * 1000; |
section.wcet.tv_sec=time.tv_sec; |
section.wcet.tv_nsec=time.tv_nsec; |
} |
Task_Section.add(section); |
task_group++; |
} |
void process_back_task(Element e, OutputStreamWriter out) { |
Pattern pattern = Pattern.compile("[us\\s]+"); |
Element act_section=e.getChild("act_section"); |
String[] start_time=pattern.split(act_section.getChild("start_time").getText()); |
Element exec_section=e.getChild("exec_section"); |
String[] exec_const=pattern.split(exec_section.getChild("exec_time").getText()); |
try { |
out.write("struct timespec act_task"+task_group+"[]={{"+start_time[0]+","+start_time[1]+"},};\n\n"); |
out.write("struct timespec exec_task"+task_group+"[]={{"+exec_const[0]+","+exec_const[1]+"},};\n\n"); |
} |
catch (java.io.IOException ex) { |
System.out.println("File Exception: " + ex.getMessage()); |
} |
} |
void process_oneshot_task(Element e, OutputStreamWriter out) { |
Pattern pattern = Pattern.compile("[us\\s]+"); |
Element act_section=e.getChild("act_section"); |
String[] start_time=pattern.split(act_section.getChild("start_time").getText()); |
Element exec_section=e.getChild("exec_section"); |
String[] exec_const=pattern.split(exec_section.getChild("exec_time").getText()); |
try { |
out.write("struct timespec act_task"+task_group+"[]={{"+start_time[0]+","+start_time[1]+"},};\n\n"); |
out.write("struct timespec exec_task"+task_group+"[]={{"+exec_const[0]+","+exec_const[1]+"},};\n\n"); |
} |
catch (java.io.IOException ex) { |
System.out.println("File Exception: " + ex.getMessage()); |
} |
} |
int process_cyclical_task(Element e, OutputStreamWriter out) { |
int activated=1; |
Pattern pattern = Pattern.compile("[us\\s]+"); |
Element act_section=e.getChild("act_section"); |
String[] start_time=pattern.split(act_section.getChild("start_time").getText()); |
String[] period=pattern.split(act_section.getChild("period_time").getText()); |
Element deltatime=act_section.getChild("delta_time"); |
String[] delta_time; |
long act_delta=0; |
timespec delta_act_ts = new timespec(); |
if (deltatime != null) { |
delta_time = pattern.split(deltatime.getText()); |
delta_act_ts.tv_sec = Long.valueOf(delta_time[0]).longValue(); |
delta_act_ts.tv_nsec = Long.valueOf(delta_time[1]).longValue() * 1000; |
act_delta = delta_act_ts.TIMESPEC2USEC(); |
} |
Element exec_section=e.getChild("exec_section"); |
String[] exec_const=pattern.split(exec_section.getChild("exec_time").getText()); |
Element execdelta=exec_section.getChild("delta_time"); |
String[] exec_delta; |
long exec_delta_long = 0; |
timespec exec_delta_ts = new timespec(); |
if (execdelta != null) { |
exec_delta=pattern.split(execdelta.getText()); |
exec_delta_ts.tv_sec = Long.valueOf(exec_delta[0]).longValue(); |
exec_delta_ts.tv_nsec = Long.valueOf(exec_delta[1]).longValue() * 1000; |
exec_delta_long = exec_delta_ts.TIMESPEC2USEC(); |
} |
try { |
out.write("struct timespec act_task"+task_group+"[]={{"+ |
start_time[0]+","+start_time[1]+"},\n"); |
timespec time = new timespec(); |
time.tv_sec = Long.valueOf(period[0]).longValue(); |
time.tv_nsec = Long.valueOf(period[1]).longValue() * 1000; |
long usecperiod = time.TIMESPEC2USEC(); |
timespec nextact = new timespec(); |
time.tv_sec = Long.valueOf(start_time[0]).longValue(); |
time.tv_nsec = Long.valueOf(start_time[1]).longValue() * 1000; |
Random rd = new Random(); |
while (simulation_time.TIMESPEC_A_GT_B(time)) { |
nextact.tv_sec = Long.valueOf(period[0]).longValue(); |
nextact.tv_nsec = Long.valueOf(period[1]).longValue() * 1000; |
if (act_delta != 0) { |
nextact.ADDUSEC2TIMESPEC((rd.nextInt() & Integer.MAX_VALUE) % act_delta - act_delta/2); |
} |
time.ADDUSEC2TIMESPEC(usecperiod); |
out.write(" {"+nextact.tv_sec+","+nextact.tv_nsec/1000+"},\n"); |
activated++; |
} |
out.write("};\n"); |
out.write("struct timespec exec_task"+task_group+"[]={\n"); |
timespec nextexec = new timespec(); |
for (int i=0; i<activated; i++) { |
nextexec.tv_sec = Long.valueOf(exec_const[0]).longValue(); |
nextexec.tv_nsec = Long.valueOf(exec_const[1]).longValue() * 1000; |
if (exec_delta_long != 0) { |
nextexec.ADDUSEC2TIMESPEC((rd.nextInt() & Integer.MAX_VALUE) % exec_delta_long - exec_delta_long/2); |
} |
out.write(" {"+nextexec.tv_sec+","+nextexec.tv_nsec/1000+"},\n"); |
} |
out.write("};\n"); |
} |
catch (java.io.IOException ex) { |
System.out.println("File Exception: " + ex.getMessage()); |
} |
return activated; |
} |
void process_server_section(Element e, OutputStreamWriter out) { |
List serverpars = e.getChildren(); |
Iterator iterator = serverpars.iterator(); |
Element serverpar = (Element) iterator.next(); |
String current_value; |
current_value=serverpar.getText(); |
try { |
out.write("{" + servernumber + ",{"); |
servernumber++; |
Pattern pattern = Pattern.compile("[us\\s]+"); |
/* cmin */ |
String[] cmin = pattern.split(current_value); |
out.write(cmin[0] + "," + Long.valueOf(cmin[1]).longValue()*1000+"},{"); |
/* tmax */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
String[] tmax = pattern.split(current_value); |
out.write(tmax[0] + "," + Long.valueOf(tmax[1]).longValue()*1000+"},{"); |
/* cmax */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
String[] cmax = pattern.split(current_value); |
out.write(cmax[0] + "," + Long.valueOf(cmax[1]).longValue()*1000+"},{"); |
/* tmin */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
String[] tmin = pattern.split(current_value); |
out.write(tmin[0] + "," + Long.valueOf(tmin[1]).longValue()*1000+"},"); |
/*work load */ |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getText(); |
out.write(current_value+","); |
serverpar = (Element) iterator.next(); |
current_value=serverpar.getName(); |
Attribute loc_type=serverpar.getAttribute("type"); |
String scheduler=loc_type.getValue(); |
if (scheduler.equals("POSIX")) { |
out.write("30"); |
} |
else if (scheduler.equals("EDF")) { |
out.write("31"); |
} |
else if (scheduler.equals("RM")) { |
out.write("32"); |
} |
out.write(",-1},\n"); |
local_scheduler.add(servernumber-1,serverpar); |
} catch (java.io.IOException ex) { |
System.out.println ("File Exception: "+ex.getMessage()); |
} |
/* |
fprintf(file_event_header, " {%d,{%d,%d},{%d,%d},{%d,%d},{%d,%d},%d,%d,-1},\n", |
(int)c->number,(int)c->cmin.tv_sec,(int)c->cmin.tv_nsec, |
(int)c->tmax.tv_sec,(int)c->tmax.tv_nsec, |
(int)c->cmax.tv_sec,(int)c->cmax.tv_nsec, |
(int)c->tmin.tv_sec,(int)c->tmin.tv_nsec, |
(int)c->workload,(int)c->local_scheduler); |
*/ |
//processElement (kid); |
} |
public static void main(String[] args) throws Exception { |
System.out.println("Parser Versione 1.0"); |
Application app = new Application(); |
if (args.length > 0) |
app.process(args[0]); |
} |
/* Event Generator |
* |
* Giacomo Guidi |
*/ |
/* |
int write_basic_par_start(void) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header, "struct loader_task loader_task_list[] = {\n"); |
fclose(file_event_header); |
return 0; |
} |
int write_basic_par(struct loader_task *c) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header, " {\"%s\",%d,%d,%d,%d,%d,{%d,%d},{%d,%d},%d,0,act_%s,exec_%s},\n", |
c->name,(int)c->task_type,(int)c->server,(int)c->local_scheduler,(int)c->number,(int)c->group, |
(int)c->deadline.tv_sec, (int)c->deadline.tv_nsec, |
(int)c->wcet.tv_sec, (int)c->wcet.tv_nsec, |
(int)c->act_number, c->name, c->name); |
fclose(file_event_header); |
return 0; |
} |
int write_contract(struct loader_contract *c) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header, " {%d,{%d,%d},{%d,%d},{%d,%d},{%d,%d},%d,%d,-1},\n", |
(int)c->number,(int)c->cmin.tv_sec,(int)c->cmin.tv_nsec, |
(int)c->tmax.tv_sec,(int)c->tmax.tv_nsec, |
(int)c->cmax.tv_sec,(int)c->cmax.tv_nsec, |
(int)c->tmin.tv_sec,(int)c->tmin.tv_nsec, |
(int)c->workload,(int)c->local_scheduler); |
fclose(file_event_header); |
return 0; |
} |
int close_loader_task(int total_task_number) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header,"};\n\n"); |
fprintf(file_event_header,"int total_loader_task = %d;\n\n",total_task_number); |
fclose(file_event_header); |
return 0; |
} |
int close_loader_contract(int total_contract_number) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header,"};\n\n"); |
fprintf(file_event_header,"int total_loader_contract = %d;\n\n",total_contract_number); |
fclose(file_event_header); |
return 0; |
} |
int write_simulation_time(struct timespec *total) |
{ |
FILE *file_event_header; |
file_event_header = fopen(EVENT_DEFINE,"a+"); |
if (file_event_header == NULL) return 1; |
fprintf(file_event_header,"struct timespec total_time = {%d,%d};\n\n",(int)total->tv_sec,(int)total->tv_nsec); |
fclose(file_event_header); |
return 0; |
} |
int write_single_act(struct timespec *t, struct loader_task *c) |
{ |
FILE *file_act_header; |
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
if (TIMESPEC_A_GT_B(t,&c->act_par_1)) { |
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d}};\n\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
c->act_number = 1; |
} else { |
fprintf(file_act_header,"struct timespec act_%s[] = {{0,0}};\n\n",c->name); |
c->act_number = 0; |
} |
fclose(file_act_header); |
return 0; |
} |
int write_periodic_act(struct timespec *t, struct loader_task *c) |
{ |
FILE *file_act_header; |
struct timespec tot_time; |
int period; |
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
c->act_number = 1; |
TIMESPEC_ASSIGN(&tot_time,&c->act_par_1); |
period = TIMESPEC2USEC(&c->act_par_2); |
while (TIMESPEC_A_GT_B(t, &tot_time)) { |
c->act_number++; |
ADDUSEC2TIMESPEC(period,&tot_time); |
fprintf(file_act_header," {%d,%d},\n", |
(int)c->act_par_2.tv_sec,(int)c->act_par_2.tv_nsec); |
} |
fprintf(file_act_header," };\n\n"); |
fclose(file_act_header); |
return 0; |
} |
int write_mean_act(struct timespec *t,struct loader_task *c) |
{ |
FILE *file_act_header; |
struct timespec tot_time; |
int next_act; |
file_act_header = fopen(ACT_LIST,"a+"); |
if (file_act_header == NULL) return 1; |
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",c->name, |
(int)c->act_par_1.tv_sec,(int)c->act_par_1.tv_nsec); |
c->act_number = 1; |
TIMESPEC_ASSIGN(&tot_time,&c->act_par_1); |
while (TIMESPEC_A_GT_B(t, &tot_time)) { |
c->act_number++; |
next_act = TIMESPEC2USEC(&c->act_par_2) + random() % TIMESPEC2USEC(&c->act_par_3) - TIMESPEC2USEC(&c->act_par_3) / 2; |
ADDUSEC2TIMESPEC(next_act,&tot_time); |
fprintf(file_act_header," {%d,%d},\n", |
next_act / 1000000, next_act % 1000000 * 1000); |
} |
fprintf(file_act_header," };\n\n"); |
fclose(file_act_header); |
return 0; |
} |
int write_exec_const(struct loader_task *c) |
{ |
FILE *file_exec_header; |
int i; |
file_exec_header = fopen(ACT_LIST,"a+"); |
if (file_exec_header == NULL) return 1; |
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",c->name, |
(int)c->exec_par_1.tv_sec,(int)c->exec_par_1.tv_nsec); |
for (i=0; i< c->act_number-1; i++) |
fprintf(file_exec_header," {%d,%d},\n", |
(int)c->exec_par_1.tv_sec,(int)c->exec_par_1.tv_nsec); |
fprintf(file_exec_header," };\n\n"); |
fclose(file_exec_header); |
return 0; |
} |
int write_exec_mean(struct loader_task *c) |
{ |
FILE *file_exec_header; |
int exec_time_usec; |
int i; |
file_exec_header = fopen(ACT_LIST,"a+"); |
if (file_exec_header == NULL) return 1; |
exec_time_usec = TIMESPEC2USEC(&c->exec_par_1) |
+ random() % TIMESPEC2USEC(&c->exec_par_2) - TIMESPEC2USEC(&c->exec_par_2) / 2; |
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",c->name, |
exec_time_usec / 1000000, exec_time_usec % 1000000 * 1000); |
for (i=0; i< c->act_number-1; i++) { |
exec_time_usec = TIMESPEC2USEC(&c->exec_par_1) |
+ random() % TIMESPEC2USEC(&c->exec_par_2) - TIMESPEC2USEC(&c->exec_par_2) / 2; |
fprintf(file_exec_header," {%d,%d},\n", |
exec_time_usec / 1000000, exec_time_usec % 1000000 * 1000); |
} |
fprintf(file_exec_header," };\n\n"); |
fclose(file_exec_header); |
return 0; |
} |
void *start; |
void *end; |
int main(int argc, char **argv) { |
char loadfile[100]; |
struct timespec total_time; |
struct loader_task *start_loader_task = NULL, *current_t; |
struct loader_contract *start_loader_contract = NULL, *current_c; |
int err,ldnum; |
int total_task_number; |
int total_contract_number; |
printf("\nEvent Generator\n"); |
if (argc < 2) { |
printf("Error: event_gen loadfile.fsf\n"); |
exit(1); |
} |
printf("Read loader file %s\n",argv[1]); |
sprintf(loadfile,"%s%s",LOADFILE_DIR,argv[1]); |
err = dos_preload(loadfile,100000,&start,&end); |
if (err != 0) { |
printf("Error: File not found\n"); |
exit(1); |
} |
printf("Parsing file\n"); |
line_reader(start, end, &total_time, &start_loader_task, &start_loader_contract); |
srandom(time(NULL)); |
write_struct(); |
current_t = start_loader_task; |
ldnum = 1; |
while(current_t != NULL) { |
sprintf(current_t->name,"ltask%d",ldnum); |
current_t->group = ldnum; |
ldnum++; |
switch (current_t->act_type) { |
case PAR_ACT_SINGLE: |
err = write_single_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
case PAR_ACT_PERIODIC: |
err = write_periodic_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
case PAR_ACT_MEAN: |
err = write_mean_act(&total_time,current_t); |
if (err != 0) { |
printf("Error writing activation header\n"); |
exit(1); |
} |
break; |
} |
switch (current_t->exec_type) { |
case PAR_EXEC_CONST: |
err = write_exec_const(current_t); |
if (err != 0) { |
printf("Error writing exec header\n"); |
exit(1); |
} |
break; |
case PAR_EXEC_MEAN: |
err = write_exec_mean(current_t); |
if (err != 0) { |
printf("Error writing exec header\n"); |
exit(1); |
} |
break; |
} |
current_t = current_t->next; |
} |
write_basic_par_start(); |
total_task_number = 0; |
current_t = start_loader_task; |
while(current_t != NULL) { |
write_basic_par(current_t); |
current_t = current_t->next; |
total_task_number++; |
} |
close_loader_task(total_task_number); |
write_contract_start(); |
total_contract_number = 0; |
current_c = start_loader_contract; |
while(current_c != NULL) { |
write_contract(current_c); |
current_c = current_c->next; |
total_contract_number++; |
} |
close_loader_contract(total_contract_number); |
write_simulation_time(&total_time); |
return 0; |
} |
*/ |
} |
/demos/trunk/loader/generators/java/java_gen |
---|
0,0 → 1,10 |
#!/bin/bash |
#if $CLASSPATH; then |
#echo Please define the CLASSPATH environment variable!!! |
#echo ...something like: export CLASSPATH=/usr/java/j2sdk1.4.2/jre/lib |
#exit 1; |
#fi |
java -classpath ".:$CLASSPATH/jdom.jar:$CLASSPATH/xercesImpl.jar:$CLASSPATH/xml-apis.jar" Application $1 |
Property changes: |
Added: svn:executable |
## -0,0 +1 ## |
+* |
\ No newline at end of property |
Index: loader/generators/java/makefile |
=================================================================== |
--- loader/generators/java/makefile (nonexistent) |
+++ loader/generators/java/makefile (revision 1609) |
@@ -0,0 +1,17 @@ |
+ifdef CLASSPATH |
+all: |
+ javac Application.java timespec.java task_class.java -classpath "$(CLASSPATH)/jdom.jar" |
+else |
+all: |
+ @echo ---------------------------------------------------------------- |
+ @echo Please define the CLASSPATH environment variable!!! |
+ @echo ...something like: export CLASSPATH=/usr/java/j2sdk1.4.2/jre/lib |
+ @echo ---------------------------------------------------------------- |
+ @exit 1 |
+endif |
+ |
+ |
+clean: |
+ rm -f *.class |
+ rm -f event.c |
+ |
Index: loader/generators/java/fsf-schema.xsd |
=================================================================== |
--- loader/generators/java/fsf-schema.xsd (nonexistent) |
+++ loader/generators/java/fsf-schema.xsd (revision 1609) |
@@ -0,0 +1,75 @@ |
+<?xml version="1.0" encoding="UTF-8"?> |
+<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'> |
+ |
+<xs:element name="fsf_framework"> |
+ <xs:complexType> |
+ <xs:sequence> |
+ <xs:element ref="simulation"/> |
+ <xs:element ref="contract" minOccurs='1' maxOccurs='unbounded'/> |
+ </xs:sequence> |
+ </xs:complexType> |
+</xs:element> |
+ |
+<xs:element name="simulation"> |
+ <xs:complexType> |
+ <xs:sequence> |
+ <xs:element name="time" type="xs:string"/> |
+ </xs:sequence> |
+ </xs:complexType> |
+</xs:element> |
+ |
+<xs:element name="contract"> |
+ <xs:complexType> |
+ <xs:sequence> |
+ <xs:element name="cmin" type="xs:string"/> |
+ <xs:element name="tmax" type="xs:string" /> |
+ <xs:element name="cmax" type="xs:string" /> |
+ <xs:element name="tmin" type="xs:string" /> |
+ <xs:element name="workload" type="xs:string" /> |
+ <xs:element ref="localscheduler"/> |
+ </xs:sequence> |
+ </xs:complexType> |
+</xs:element> |
+ |
+<xs:element name="localscheduler"> |
+ <xs:complexType> |
+ <xs:sequence> |
+ <xs:element ref="task_section" minOccurs='1' maxOccurs='unbounded'/> |
+ </xs:sequence> |
+ <xs:attribute name="type" type="xs:string" use='required'/> |
+ </xs:complexType> |
+</xs:element> |
+ |
+<xs:element name="task_section"> |
+ <xs:complexType> |
+ <xs:sequence> |
+ <xs:element name="number" type="xs:integer"/> |
+ <xs:element name="dline" type="xs:string" minOccurs="0" /> |
+ <xs:element name="wcet" type="xs:string" minOccurs="0"/> |
+ <xs:element ref="act_section"/> |
+ <xs:element ref="exec_section"/> |
+ </xs:sequence> |
+ <xs:attribute name="type" type="xs:string" use='required'/> |
+ </xs:complexType> |
+</xs:element> |
+ |
+<xs:element name="act_section"> |
+ <xs:complexType> |
+ <xs:sequence> |
+ <xs:element name="start_time" type="xs:string"/> |
+ <xs:element name="period_time" type="xs:string" minOccurs="0" /> |
+ <xs:element name="delta_time" type="xs:string" minOccurs="0" /> |
+ </xs:sequence> |
+ </xs:complexType> |
+</xs:element> |
+ |
+<xs:element name="exec_section"> |
+ <xs:complexType> |
+ <xs:sequence> |
+ <xs:element name="exec_time" type="xs:string"/> |
+ <xs:element name="delta_time" type="xs:string" minOccurs="0" /> |
+ </xs:sequence> |
+ </xs:complexType> |
+</xs:element> |
+ |
+</xs:schema> |
Index: loader/generators/java/task_class.java |
=================================================================== |
--- loader/generators/java/task_class.java (nonexistent) |
+++ loader/generators/java/task_class.java (revision 1609) |
@@ -0,0 +1,26 @@ |
+//package first_filter; |
+ |
+/** |
+ * <p>Title: First XML filter</p> |
+ * <p>Description: </p> |
+ * <p>Copyright: Copyright (c) 2003</p> |
+ * <p>Company: Retis Lab</p> |
+ * @author not attributable |
+ * @version 1.0 |
+ */ |
+ |
+public class task_class { |
+ String name; |
+ int task_type; |
+ int contract; |
+ int localscheduler; |
+ int number; |
+ int group; |
+ timespec deadline; |
+ timespec wcet; |
+ int act_number; |
+ |
+ public task_class() { |
+ } |
+ |
+} |
Index: loader/generators/java/timespec.java |
=================================================================== |
--- loader/generators/java/timespec.java (nonexistent) |
+++ loader/generators/java/timespec.java (revision 1609) |
@@ -0,0 +1,37 @@ |
+//package first_filter; |
+ |
+/** |
+ * <p>Title: First XML filter</p> |
+ * <p>Description: </p> |
+ * <p>Copyright: Copyright (c) 2003</p> |
+ * <p>Company: Retis Lab</p> |
+ * @author not attributable |
+ * @version 1.0 |
+ */ |
+ |
+public class timespec { |
+ long tv_sec; |
+ long tv_nsec; |
+ |
+ public timespec() { |
+ tv_sec=0; |
+ tv_nsec=0; |
+ } |
+ |
+ |
+ void ADDUSEC2TIMESPEC(long t1) { |
+ tv_nsec+=(t1%1000000)*1000; |
+ tv_sec+=(tv_nsec / 1000000000)+(t1/1000000); |
+ tv_nsec%=1000000000; |
+ } |
+ long TIMESPEC2USEC() { |
+ return (tv_sec*1000000+tv_nsec/1000); |
+ } |
+ boolean TIMESPEC_A_GT_B(timespec t1) { |
+ |
+ return (tv_sec>t1.tv_sec || |
+ (tv_sec==t1.tv_sec && tv_nsec>t1.tv_nsec)); |
+ |
+ } |
+ |
+} |
Index: loader/generators/makefile |
=================================================================== |
--- loader/generators/makefile (nonexistent) |
+++ loader/generators/makefile (revision 1609) |
@@ -0,0 +1,9 @@ |
+event_gen: |
+ gcc -o lparser.o -c -Wall lparser.c -I. -I.. |
+ gcc -o lread.o -c -Wall lread.c -I. -I.. |
+ gcc -o event_gen -Wall lparser.o lread.o -I. -I.. -lc event_gen.c |
+ |
+clean: |
+ rm -f *.o |
+ rm -f event_gen |
+ |
Index: loader/generators/lread.c |
=================================================================== |
--- loader/generators/lread.c (nonexistent) |
+++ loader/generators/lread.c (revision 1609) |
@@ -0,0 +1,95 @@ |
+#include <stdio.h> |
+#include <stdlib.h> |
+#include "lparser.h" |
+#include "common/time.h" |
+ |
+int dos_preload(char *file_name, long max_size, void **start_file, void **end_file) |
+{ |
+ FILE *file; |
+ void *buf; |
+ long rd; |
+ |
+ |
+ file = fopen(file_name,"r"); |
+ if (file == NULL) return -1; |
+ |
+ buf = malloc(max_size); |
+ *start_file = buf; |
+ |
+ while(((rd = fread(buf, 1, 2048, file)) == 2048) && |
+ ((buf - *start_file + rd) < (max_size-2048))) { |
+ buf += rd; |
+ } |
+ |
+ *end_file = buf + rd; |
+ |
+ fclose(file); |
+ return(0); |
+ |
+} |
+ |
+int line_reader(void *start_file, void *end_file, struct timespec *total, |
+ struct loader_task **start_loader_task, struct loader_contract **start_loader_contract) |
+{ |
+ |
+ char *pbuf = start_file; |
+ int res,line_num,total_loader_task,total_loader_contract; |
+ struct loader_task *current_t = NULL; |
+ struct loader_contract *current_c = NULL; |
+ |
+ NULL_TIMESPEC(total); |
+ |
+ line_num = 0; |
+ total_loader_task = 0; |
+ total_loader_contract = 0; |
+ |
+ while ((void *)(pbuf) < end_file) { |
+ |
+ line_num++; |
+ |
+ if (*start_loader_contract == NULL) |
+ res = line_parser_contract(&pbuf, line_num, total, ¤t_c); |
+ else |
+ res = line_parser_contract(&pbuf, line_num, total, ¤t_c->next); |
+ |
+ if (res == 2) { |
+ total_loader_contract++; |
+ if (*start_loader_contract == NULL) |
+ *start_loader_contract = current_c; |
+ else |
+ current_c = current_c->next; |
+ } |
+ |
+ if (res == 3) break; |
+ |
+ } |
+ |
+ while ((void *)(pbuf) < end_file) { |
+ |
+ line_num++; |
+ |
+ if (*start_loader_task == NULL) |
+ res = line_parser_task(&pbuf, line_num, ¤t_t); |
+ else |
+ res = line_parser_task(&pbuf, line_num, ¤t_t->next); |
+ |
+ if (res == 2) { |
+ total_loader_task++; |
+ if (*start_loader_task == NULL) |
+ *start_loader_task = current_t; |
+ else |
+ current_t = current_t->next; |
+ } |
+ |
+ if (res == 3) break; |
+ |
+ } |
+ |
+ printf("Total decoded lines %d\n",line_num); |
+ printf("Total loader contract %d\n",total_loader_contract); |
+ printf("Total loader task %d\n",total_loader_task); |
+ printf("Simulation time sec = %ld usec = %ld\n",total->tv_sec,total->tv_nsec/1000); |
+ |
+ return 0; |
+ |
+} |
Index: loader/generators/lread.h |
=================================================================== |
--- loader/generators/lread.h (nonexistent) |
+++ loader/generators/lread.h (revision 1609) |
@@ -0,0 +1,11 @@ |
+#ifndef __LREAD_H__ |
+#define __LREAD_H__ |
+ |
+#include "lparser.h" |
+ |
+int dos_preload(char *file_name, long max_size, void **start, void **end); |
+ |
+int line_reader(void *start, void *end, struct timespec *total, |
+ struct loader_task **start_loader_task, struct loader_contract **start_loader_contract); |
+ |
+#endif |
Index: loader/marte/makefile.in |
=================================================================== |
--- loader/marte/makefile.in (nonexistent) |
+++ loader/marte/makefile.in (revision 1609) |
@@ -0,0 +1,7 @@ |
+# |
+# MaRTE OS dependecies |
+# |
+ |
+os_specific_dep: |
+ echo MaRTE dependencies here |
+ |