Subversion Repositories shark

/*

 * step 3: generation of the configuration file for CRUNCH

 */

#include <stdio.h>

// Patterns

#define MAX_PATTERN 10000

int max_hpattern = 0;

int hpattern_t[MAX_PATTERN];

int hpattern_period[MAX_PATTERN];

int hpattern_wcet[MAX_PATTERN];

int hpattern_iter[MAX_PATTERN];

int hpattern_index=0;

int max_vpattern = 0;

int vpattern_t[MAX_PATTERN];

int vpattern_period[MAX_PATTERN];

int vpattern_wcet[MAX_PATTERN];

int vpattern_iter[MAX_PATTERN];

int vpattern_value[MAX_PATTERN];

int vpattern_penalty[MAX_PATTERN];

int vpattern_index=0;

// Data structores needed for crunch

#define MAX_CRUNCH 10000

int crunch_max = 0;

int crunch_t[MAX_CRUNCH];

int crunch_type[MAX_CRUNCH];

int crunch_dline[MAX_CRUNCH];

int crunch_wcet[MAX_CRUNCH];

int crunch_iterations[MAX_CRUNCH];

int crunch_value[MAX_CRUNCH];

int crunch_penalty[MAX_CRUNCH];

void read_hpattern(char *);

void read_vpattern(char *);

void merge_dat(void);

void write_dat(void);

int main(int argc, char **argv)

{

  if (argc != 3) {

    fprintf(stderr,"Usage: step4 hpattern.dat vpattern.dat\n\n");

    exit(0);

  }

  read_hpattern(argv[1]);

  read_vpattern(argv[2]);

  merge_dat();

  write_dat();

  return 0;

}

/*

 *

 * Reading/Writing patterns

 *

 */

/*

 * This function read from a file written in the format of

 * hpattern.dat, and fills the internal pattern data structure.

 */

void read_hpattern(char *name)

{

  int i;

  FILE *f;

  f = fopen(name,"r");

  fscanf(f,"%d", &max_hpattern);

  for (i=0; i<max_hpattern; i++) {

    fscanf(f,"%d %d %d %d", &hpattern_t[i], &hpattern_period[i],

          &hpattern_wcet[i], &hpattern_iter[i]);

//    printf("Hard %d %d %d %d\n", hpattern_t[i], hpattern_period[i],

//          hpattern_wcet[i], hpattern_iter[i]);

  }

}

/*

 * This function read from a file written in the format of

 * vpattern.dat, and fills the internal pattern data structure.

 */

void read_vpattern(char *name)

{

  int i;

  FILE *f;

  f = fopen(name,"r");

  fscanf(f,"%d", &max_vpattern);

  for (i=0; i<max_vpattern; i++) {

    fscanf(f,"%d %d %d %d %d %d",

          &vpattern_t[i], &vpattern_period[i],

          &vpattern_wcet[i], &vpattern_iter[i],

          &vpattern_value[i], &vpattern_penalty[i]);

//    printf("Value %d %d %d %d %d %d\n", vpattern_t[i], vpattern_period[i],

//          vpattern_wcet[i], vpattern_iter[i],

//          vpattern_value[i], vpattern_penalty[i]);

  }

}

#define INSERT_V 1

#define INSERT_H 2

void merge_dat(void)

{

  int h_i, v_i;

  int todo = 0;

  h_i = 0;

  v_i = 0;

  while (!(h_i == max_hpattern && v_i == max_vpattern)) {

    if (h_i < max_hpattern)

      // there are h available

      if (v_i < max_vpattern)

        // random and bad available

        if (vpattern_t[v_i] < hpattern_t[h_i])

          todo = INSERT_V;

        else

          todo = INSERT_H;

      else

        // only H

        todo = INSERT_H;

    else

      // only bad available

      todo = INSERT_V;

    if (todo == INSERT_V) {

      crunch_t[crunch_max] = vpattern_t[v_i];

      crunch_type[crunch_max] = 1;

      crunch_dline[crunch_max] = vpattern_period[v_i];

      crunch_wcet[crunch_max] = vpattern_wcet[v_i];

      crunch_iterations[crunch_max] = vpattern_iter[v_i];

      crunch_value[crunch_max] = vpattern_value[v_i];

      crunch_penalty[crunch_max] = vpattern_penalty[v_i];

      crunch_max++;

      v_i++;

    }

    else {

      crunch_t[crunch_max] = hpattern_t[h_i];

      crunch_type[crunch_max] = 0;

      crunch_dline[crunch_max] = hpattern_period[h_i];

      crunch_wcet[crunch_max] = hpattern_wcet[h_i];

      crunch_iterations[crunch_max] = hpattern_iter[h_i];

      crunch_value[crunch_max] = 0;

      crunch_penalty[crunch_max] = 0;

      crunch_max++;

      h_i++;

    }

  }

}

void write_dat(void)

{

  int i;

  printf("%d\n", crunch_max);

  for (i=0; i<crunch_max; i++)

    printf("%d %d %d %d %d %d %d\n",

           crunch_t[i], crunch_type[i], crunch_dline[i], crunch_wcet[i],

           crunch_iterations[i], crunch_value[i], crunch_penalty[i]);

}