Subversion Repositories shark

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

}