WebSVN - shark - Rev 1304 - /demos/trunk/loader/generators/event

/* 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,-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_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;

}

Subversion Repositories shark

(root)/demos/trunk/loader/generators/event_gen.c @ 1369 - Rev 1304