Subversion Repositories shark

Compare Revisions

Ignore whitespace Rev 1237 → Rev 1236

/demos/trunk/loader/time.h
File deleted
/demos/trunk/loader/load.txt
File deleted
/demos/trunk/loader/lparser.c
File deleted
/demos/trunk/loader/lparser.h
File deleted
/demos/trunk/loader/lread.c
File deleted
/demos/trunk/loader/lread.h
File deleted
/demos/trunk/loader/event_gen.c
6,14 → 6,18
#include <stdio.h>
#include <stdlib.h>
 
#include "parser.h"
#include "time.h"
 
#define EVENT_HEADER "eventh.h"
#define EVENT_DEFINE "eventc.c"
#define EVENT_HEADER "event_header.h"
#define ACT_LIST "act_list.h"
 
#define ACT_SINGLE 0
#define ACT_PERIODIC 1
#define ACT_MEAN 2
#define ACT_INVALID 3
 
#define EXEC_CONST 0
#define EXEC_MEAN 1
#define EXEC_INVALID 2
 
int act_number;
 
int write_struct(void)
21,11 → 25,10
 
FILE *file_event_header;
 
file_event_header = fopen(EVENT_DEFINE,"w");
file_event_header = fopen(EVENT_HEADER,"w");
if (file_event_header == NULL) return 1;
 
fprintf(file_event_header, "\n#include \"event_gen.h\"\n");
fprintf(file_event_header, "#include \"%s\"\n",ACT_LIST);
fprintf(file_event_header, "\n#include \"%s\"\n\n",ACT_LIST);
 
fprintf(file_event_header, "struct loader_task loader_task_list[] = {\n");
 
35,18 → 38,43
 
}
 
int write_basic_par(struct loader_task *c)
int select_basic_par(char *task_name)
{
 
int number,group,server,deadline,wcet,local_scheduler;
FILE *file_event_header;
 
file_event_header = fopen(EVENT_DEFINE,"a+");
printf("\nInsert the number of tasks\n");
printf("> ");
scanf("%d",&number);
printf("Insert the group number\n");
printf("> ");
scanf("%d",&group);
printf("Insert the server number\n");
printf("> ");
scanf("%d",&server);
 
printf("Insert the local scheduler type\n");
printf(" 0 - POSIX\n");
printf(" 1 - EDF\n");
printf(" 2 - RM\n");
printf(" 3 - MPEGSTAR\n");
printf("> ");
scanf("%d",&local_scheduler);
 
printf("Insert the deadline [us]\n");
printf("> ");
scanf("%d",&deadline);
printf("Insert the wcet [us]\n");
printf("> ");
scanf("%d",&wcet);
 
file_event_header = fopen(EVENT_HEADER,"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,c->task_type,c->server,c->local_scheduler,c->number,c->group,
c->deadline.tv_sec, c->deadline.tv_nsec,c->act_number,
c->wcet.tv_sec, c->wcet.tv_nsec, c->name, c->name, c->name);
fprintf(file_event_header, " {\"%s\",%d,%d,%d,%d,{%d,%d},{%d,%d},ACT_NUMBER_%s,act_%s,exec_%s},\n",
task_name,number,group,server,local_scheduler,deadline / 1000000, deadline % 1000000 * 1000,
wcet / 1000000, wcet % 1000000 * 1000, task_name, task_name, task_name);
 
fclose(file_event_header);
 
59,7 → 87,7
 
FILE *file_event_header;
 
file_event_header = fopen(EVENT_DEFINE,"a+");
file_event_header = fopen(EVENT_HEADER,"a+");
if (file_event_header == NULL) return 1;
 
fprintf(file_event_header,"};\n\n");
70,23 → 98,100
 
}
 
int write_single_act(struct timespec *t, struct loader_task *c)
int select_act_type(void)
{
char act_type[10];
 
printf("\nInsert the activation type\n");
printf(" S - Single\n");
printf(" P - Periodic\n");
printf(" M - Sporadic with constant distribution (Mean,Delta)\n");
printf("> ");
scanf("%s",act_type);
 
switch (act_type[0]) {
 
case 's':
case 'S':
 
return ACT_SINGLE;
break;
 
case 'p':
case 'P':
return ACT_PERIODIC;
break;
case 'm':
case 'M':
return ACT_MEAN;
break;
 
default:
 
return ACT_INVALID;
}
 
return ACT_INVALID;
 
}
 
int select_exec_type(void)
{
char exec_type[10];
printf("\nInsert the execution time\n");
printf(" C - Const Exec Time\n");
printf(" M - Variable with constant distribution (Mean,Delta)\n");
printf("> ");
scanf("%s",exec_type);
switch (exec_type[0]) {
case 'c':
case 'C':
return EXEC_CONST;
break;
case 'm':
case 'M':
return EXEC_MEAN;
break;
default:
 
return EXEC_INVALID;
 
}
 
return EXEC_INVALID;
 
}
 
int write_single_act(char *task_name)
{
 
FILE *file_act_header;
int time_usec;
 
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,
c->act_par_1.tv_sec,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;
}
act_number = 1;
fprintf(file_act_header,"\n#define ACT_NUMBER_%s %d\n\n",task_name,act_number);
 
printf("\nInsert single activation time [us]\n");
printf("> ");
scanf("%d",&time_usec);
 
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d}};\n\n",task_name,
time_usec/1000000,time_usec%1000000*1000);
 
fclose(file_act_header);
 
return 0;
93,28 → 198,36
 
}
 
int write_periodic_act(struct timespec *t, struct loader_task *c)
int write_periodic_act(char *task_name)
{
 
FILE *file_act_header;
int i;
struct timespec tot_time;
int period;
int i,first_time_usec,per_time_usec;
long long tot_time_usec;
 
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,
c->act_par_1.tv_sec,c->act_par_1.tv_nsec);
printf("\nInsert the number of activations\n");
printf("> ");
scanf("%d",&act_number);
printf("Insert first activation time [us]\n");
printf("> ");
scanf("%d",&first_time_usec);
printf("Insert periodic activation time [us]\n");
printf("> ");
scanf("%d",&per_time_usec);
fprintf(file_act_header,"\n#define ACT_NUMBER_%s %d\n\n",task_name,act_number);
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",task_name,
first_time_usec/1000000,first_time_usec%1000000*1000);
 
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);
tot_time_usec = first_time_usec;
for (i=0;i<act_number-1;i++) {
tot_time_usec += per_time_usec;
fprintf(file_act_header," {%d,%d},\n",
c->act_par_2.tv_sec,c->act_par_2.tv_nsec);
(int)tot_time_usec/1000000,(int)tot_time_usec%1000000*1000);
}
 
fprintf(file_act_header," };\n\n");
125,28 → 238,39
 
}
 
int write_mean_act(struct timespec *t,struct loader_task *c)
int write_mean_act(char *task_name)
{
 
FILE *file_act_header;
int i,first_time_usec,mean_time_usec,delta_time_usec;
struct timespec tot_time;
int next_act;
long long tot_time_usec;
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,
c->act_par_1.tv_sec,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);
printf("\nInsert the number of activations\n");
printf("> ");
scanf("%d",&act_number);
printf("Insert first activation time [us]\n");
printf("> ");
scanf("%d",&first_time_usec);
printf("Insert mean peridic time [us]\n");
printf("> ");
scanf("%d",&mean_time_usec);
printf("Insert delta time [us]\n");
printf("> ");
scanf("%d",&delta_time_usec);
 
fprintf(file_act_header,"\n#define ACT_NUMBER_%s %d\n\n",task_name,act_number);
fprintf(file_act_header,"struct timespec act_%s[] = {{%d,%d},\n",task_name,
first_time_usec/1000000,first_time_usec%1000000*1000);
tot_time_usec = first_time_usec;
for (i=0;i<act_number-1;i++) {
tot_time_usec += mean_time_usec + random() % delta_time_usec - delta_time_usec/2;
fprintf(file_act_header," {%d,%d},\n",
next_act / 1000000, next_act % 1000000 * 1000);
(int)tot_time_usec/1000000,(int)tot_time_usec%1000000*1000);
}
fprintf(file_act_header," };\n\n");
157,7 → 281,7
}
 
int write_exec_const(struct loader_task *c)
int write_exec_const(char *task_name)
{
 
FILE *file_exec_header;
166,12 → 290,16
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,
c->exec_par_1.tv_sec,c->exec_par_1.tv_nsec);
printf("Insert execution time [us]\n");
printf("> ");
scanf("%d",&exec_time_usec);
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",task_name,
exec_time_usec/1000000,exec_time_usec%1000000*1000);
 
for (i=0; i< act_number-1; i++)
fprintf(file_exec_header," {%d,%d},\n",
c->exec_par_1.tv_sec,c->exec_par_1.tv_nsec);
exec_time_usec/1000000,exec_time_usec%1000000*1000);
 
fprintf(file_exec_header," };\n\n");
181,25 → 309,31
 
}
 
int write_exec_mean(struct loader_task *c)
int write_exec_mean(char *task_name)
{
FILE *file_exec_header;
struct timespec exec_time;
int i;
int exec_time_usec,mean_time_usec,delta_time_usec,i;
file_exec_header = fopen(ACT_LIST,"a+");
if (file_exec_header == NULL) return 1;
//exec_time_usec = mean_time_usec + random() % delta_time_usec - delta_time_usec / 2;
printf("Insert mean execution time [us]\n");
printf("> ");
scanf("%d",&mean_time_usec);
printf("Insert delta execution time [us]\n");
printf("> ");
scanf("%d",&delta_time_usec);
 
exec_time_usec = mean_time_usec + random() % delta_time_usec - delta_time_usec / 2;
fprintf(file_exec_header,"struct timespec exec_%s[] = {{%d,%d},\n",
c->exec_par_1.tv_sec,c->exec_par_1.tv_nsec);
TIMESPEC_ASSIGN(&exec_time,&c->exec_par_1); for (i=0; i< act_number-1; i++) {
//exec_time_usec = mean_time_usec + random() % delta_time_usec - delta_time_usec / 2;
exec_time_usec/1000000,exec_time_usec%1000000*1000);
for (i=0; i< act_number-1; i++) {
exec_time_usec = mean_time_usec + random() % delta_time_usec - delta_time_usec / 2;
fprintf(file_exec_header," {%d,%d},\n",
exec_time.tv_sec,exec_time.tv_nsec);
exec_time_usec/1000000,exec_time_usec%1000000*1000);
}
fprintf(file_exec_header," };\n\n");
210,58 → 344,53
}
 
void *start;
void *end;
 
int main(void) {
 
char task_name[100];
char act_type,exec_type;
struct timespec total_time;
struct loader_task *start_loader_task, *current;
int err,ldnum;
int err;
 
printf("\nEvent Generator\n");
printf("\nEvent Generator\n\n");
 
printf("Read loader file\n");
 
dos_preload("loadfile.txt",100000,&start,&end);
 
printf("Parsing file\n");
 
line_reader(start, end, &total_time, &start_loader_task);
 
srandom(12354132);
 
write_struct();
 
current = start_loader_task;
ldnum = 0;
while(1) {
 
while(current != NULL) {
printf("Insert the task name\n");
printf("Write \"q\" to quit program\n");
printf("> ");
scanf("%s",task_name);
 
sprintf(current->name,"ltask%d",ldnum);
current->group = ldnum;
if (strlen(task_name) == 1 && task_name[0] == 'q') {
close_loader();
exit(0);
}
 
write_basic_par(current);
select_basic_par(task_name);
 
switch (current->act_type) {
case PAR_ACT_SINGLE:
err = write_single_act(&total_time,current);
while((act_type = select_act_type()) == ACT_INVALID) {
printf("Error: Invalid Act Type\n");
}
 
switch (act_type) {
case ACT_SINGLE:
err = write_single_act(task_name);
if (err != 0) {
printf("Error writing activation header\n");
exit(1);
}
break;
case PAR_ACT_PERIODIC:
err = write_periodic_act(&total_time,current);
case ACT_PERIODIC:
err = write_periodic_act(task_name);
if (err != 0) {
printf("Error writing activation header\n");
exit(1);
}
break;
case PAR_ACT_MEAN:
err = write_mean_act(&total_time,current);
case ACT_MEAN:
err = write_mean_act(task_name);
if (err != 0) {
printf("Error writing activation header\n");
exit(1);
269,16 → 398,20
break;
}
 
switch (current->exec_type) {
case PAR_EXEC_CONST:
err = write_exec_const(current);
while((exec_type = select_exec_type()) == EXEC_INVALID) {
printf("Error: Invalid Exec Type\n");
}
switch (exec_type) {
case EXEC_CONST:
err = write_exec_const(task_name);
if (err != 0) {
printf("Error writing exec header\n");
exit(1);
}
break;
case PAR_EXEC_MEAN:
err = write_exec_mean(current);
case EXEC_MEAN:
err = write_exec_mean(task_name);
if (err != 0) {
printf("Error writing exec header\n");
exit(1);
286,12 → 419,8
break;
}
 
current = current->next;
 
}
 
close_loader();
 
return 0;
 
}
/demos/trunk/loader/makefile
12,8 → 12,5
include $(BASE)/config/example.mk
 
newloader:
#make -f $(SUBMAKE) APP=newloader INIT= OTHEROBJS="fsfinit.o initfile.o shark.o" OTHERINCL= SHARKOPT="__OLDCHAR__ __FIRST__"
gcc -o lread.o -c lread.c
gcc -o lparser.o -c lparser.c
gcc -o event_gen event_gen.c lparser.o lread.o
make -f $(SUBMAKE) APP=newloader INIT= OTHEROBJS="fsfinit.o initfile.o shark.o" OTHERINCL= SHARKOPT="__OLDCHAR__ __FIRST__"
 
/demos/trunk/loader/event_gen.h
3,17 → 3,15
struct loader_task {
 
char name[20];
int task_type;
int number;
int group;
int server;
int local_scheduler;
int number;
int group;
struct timespec deadline;
struct timespec wcet;
int act_number;
int act_current;
 
struct timespec *act;
struct timespec *exec;