Subversion Repositories shark

#include <kernel/kern.h>
#include "parser.h"
#include "dosread.h"

extern void *start;
extern void *end;

struct timespec zero_time;

TASK nrt_test_task(void *arg)
{
  int i;

  cprintf("(Act %d)",exec_shadow);

  while(1) {

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

  }
 
  return NULL;

}

TASK test_task(void *arg)
{
  int i;  

  cprintf("(Act %d)",exec_shadow);

  while(1) {

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

    task_endcycle();

  }

  return NULL;

}

void loader_task_create(struct loader_task *start_loader_task)
{

  struct loader_task *current = start_loader_task;
  int i, total_task;
  int total_group = 0;
  PID p;

  total_task = 0;

  while (current != NULL) {

    total_group++;
    current->group = total_group;

    for (i=0; i < current->number; i++) {

      if (current->task_type == PAR_TASK_NRT) {
        NRT_TASK_MODEL nrt;
     
        nrt_task_default_model(nrt);
        nrt_task_def_save_arrivals(nrt);
        nrt_task_def_arg(nrt,(void *)(current));
        nrt_task_def_ctrl_jet(nrt);
        nrt_task_def_level(nrt,current->task_level);
        nrt_task_def_group(nrt,total_group);

        p = task_create("NRT",nrt_test_task,&nrt,NULL);
        if (p == NIL) {
          cprintf("Error nrt task creating\n");
          sys_end();
        }

        total_task++;

      }

      if (current->task_type == PAR_TASK_HARD) {
        HARD_TASK_MODEL ht;
                                                                                                                             
        hard_task_default_model(ht);
        hard_task_def_arg(ht,(void *)(current));
        hard_task_def_wcet(ht,TIMESPEC2USEC(&current->wcet));
        hard_task_def_ctrl_jet(ht);
        hard_task_def_level(ht,current->task_level);
        hard_task_def_group(ht,total_group);

        if (current->act_type == PAR_ACT_PERIODIC) {
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
        } else if (current->act_type != PAR_ACT_SINGLE) {
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->act_par_2));
          hard_task_def_aperiodic(ht);
        } else {
          hard_task_def_mit(ht,TIMESPEC2USEC(&current->wcet)*100);
          hard_task_def_aperiodic(ht);
        }
                                                                                                                             
        p = task_create("HARD",test_task,&ht,NULL);
        if (p == NIL) {
          cprintf("Error hard task creating\n");
          sys_end();
        }

        total_task++;
                                                                                                                             
      }

      if (current->task_type == PAR_TASK_SOFT) {
        SOFT_TASK_MODEL st;
                                                                                                                             
        soft_task_default_model(st);
        soft_task_def_save_arrivals(st);
        soft_task_def_arg(st,(void *)(current));
        soft_task_def_met(st,TIMESPEC2USEC(&current->wcet));
        soft_task_def_ctrl_jet(st);
        soft_task_def_level(st,current->task_level);
        soft_task_def_group(st,total_group);

        if (current->act_type == PAR_ACT_PERIODIC) {
          soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
        } else if (current->act_type != PAR_ACT_SINGLE) {
          soft_task_def_period(st,TIMESPEC2USEC(&current->act_par_2));
          soft_task_def_aperiodic(st);
        } else {
          soft_task_def_period(st,TIMESPEC2USEC(&current->wcet)*100);
          soft_task_def_aperiodic(st);
        }
                                                                                                                             
        p = task_create("SOFT",test_task,&st,NULL);
        if (p == NIL) {
          cprintf("Error soft task creating\n");
          sys_end();
        }

        total_task++;
                                                                                                                             
      }

    }

    current = current->next;

  }

  cprintf("Created %d tasks\n",total_task);
 
}

void loader_first_execution(struct loader_task *start_loader_task)
{

  struct loader_task *current = start_loader_task;
  struct timespec start_time;  

  while (current != NULL) {
 
    ADDTIMESPEC(&zero_time,&current->act_par_1,&start_time);

    kern_event_post(&start_time, (void *)((void *)group_activate), (void *)(current->group));

    current = current->next;

  }  

}

int main()
{

  struct loader_task *start_loader_task = NULL;
  struct timespec total;
  struct timespec end_time;

  line_reader(start, end, &total, &start_loader_task);

  loader_task_create(start_loader_task);
 
  kern_gettime(&zero_time);

  loader_first_execution(start_loader_task);

  ADDTIMESPEC(&zero_time,&total,&end_time);
  kern_event_post(&end_time,(void *)((void *)(sys_end)),NULL);

  return 0;

}