Subversion Repositories shark

/*
 * Project: REPPOR
 *
 *
 File:        $File$
 Last update: $Date: 2004/04/08
 ------------
**/

/*
 * Copyright (C) 2004 Pankaj Arora,Gangadharan & Arjumand Ara.
 *
 * This program is free software; you can redistribute it and/or modify
 * it. This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

 */

/*--------------------------------------------------------------*/
/*              SIMULATION OF REal time Prey PredatOR--REPPOR   */
/*--------------------------------------------------------------*/

#include "datastructures.h"

struct Prey chuha;


/*--------------------------------------------------------------*/
/*     Function to draw predator                        */
/*     Parameters : Old x,y position
                    New x,y position
                    Old color
                    New color
       Return      : none
/*--------------------------------------------------------------*/

void   draw_saamp(int oldx, int oldy,int newx,int newy,int oldcolor, int newcolor)
{
        sem_wait(&grx_mutex);
        grx_disc(oldx, oldy, RAD, oldcolor);
        grx_disc(newx, newy, RAD, newcolor);
        sem_post(&grx_mutex);
}

/*--------------------------------------------------------------*/
/*     Function to draw prey                        */
/*     Parameters : Old x,y position
                    New x,y position                    
       Return      : none
/*--------------------------------------------------------------*/

void    draw_prey(int oldx,int oldy,int newx, int newy)
{
        sem_wait(&grx_mutex);
        grx_circle(oldx,oldy,PREY_RAD, GREEN);
        grx_circle(newx, newy, PREY_RAD, BLACK);
        sem_post(&grx_mutex);
}
/*--------------------------------------------------------------*/
/*     Function to genearte a random number between a given range*/
/*     Parameters : Minimum of range
                    Maximun of range
       Return     : Genearted random number
/*--------------------------------------------------------------*/

int generateRandomNumber(int minR, int maxR )
{
  int temp = rand();
  temp = temp % (maxR+1);
  while(temp < minR)
  {
    temp = rand();
    temp = temp % (maxR+1);
  }
  return temp;
}

/*--------------------------------------------------------------*/
/*     Function to implement periodic task JET                        */
/*     Description : It fetches the execution time for the tasks in the system.
                     Then computes the Mean Execution Time of the Predator Tasks and
                     displays it along with their corresponding periods.
/*----------------------------------------------------------------------------------------*/

TASK jet_task(void *arg){

        TIME sum, max, curr;
        TIME total[24];
        PID id;

        char *buf;
        char tmp[48];

        int i=0;
        int n;
        int JNTASK=0;
        int JXT = 480;
        int JX = 535;
        int JY = 310;
        int JWIDTH = 50;

        int width;
        int widthperiod = 0;
        int maxperiod = 80000; 
        float period=0;
        float met;

        memset(buf, '\0', sizeof(buf));
        grx_text("MET PERIOD", JXT+10, JY-8, LIGHTCYAN, BLACK);
        grx_rect(JXT-4, JY-12, JXT+150, JY+160,WHITE1);
        while (1){
                for (id=2, JNTASK=0; id < MAX_PROC; id++){
                        if (jet_getstat(id, &sum, &max, &n, &curr) != -1)
                         {
                                met = (float) (sum+curr)/n;
                                buf = proc_table[id].name;
                                i=JNTASK++;

                        if (strcmp(buf,SNAKE_R) == 0) {
                                period = sam_red_period;
                                grx_text(buf, JXT, JY+i*8, MAGENTA, BLACK);
                         
                                widthperiod = (int) ( (period/maxperiod) *JWIDTH);
                                width = (int) ((float) met/widthperiod);

                                grx_box(JX, JY+i*8, JX+widthperiod, JY+8+i*8, LIGHTRED);
                                grx_box(JX, JY+i*8, JX+width, JY+8+i*8, RED);
                        }
                        else if (strcmp(buf,SNAKE_B) == 0) {
                                period = sam_blue_period;
                                grx_text(buf, JXT, JY+ i*8, MAGENTA, BLACK);

                                widthperiod = (int) ( (period/maxperiod) *JWIDTH);
                                width = (int) ((float) met/widthperiod);

                                grx_box(JX, JY+i*8, JX+widthperiod, JY+8+i*8, LIGHTBLUE);
                                grx_box(JX, JY+i*8, JX+width, JY+8+i*8, BLUE);
                        }
                        else if (strcmp(buf,SNAKE_Y) == 0) {
                                period = sam_yellow_period;                        
                                grx_text(buf, JXT, JY+i*8, MAGENTA, BLACK);

                                widthperiod = (int) ( (period/maxperiod) *JWIDTH);
                                width = (int) ((float) met/widthperiod);

                                grx_box(JX, JY+i*8, JX+widthperiod, JY+8+i*8, YELLOW);
                                grx_box(JX, JY+i*8, JX+width, JY+8+i*8, GREEN);
                        }
                }
                }
                task_endcycle();
        }
}


/*-----------------------------------------------------------------------------*/
/*     Function to implement periodic task BarGraph             */
/*     Description : Calculates number of preys killed by each(Red/Blue/Yellow)
                     type of predator and then makes a bar graph presenting score
                     percentages.                      
/*------------------------------------------------------------------------------*/

TASK make_bargraph(void  *arg)
{
  int i;
  int x1,y1,x2,y2;
 
  while(1)
 {
  for(i=INITIAl_TASKS;i<=MAXTASKS;i++)
    if(saamps[i].number_of_times_killed>0)
      {  
        if(saamps[i].color==LIGHTRED1)
             red_killed += saamps[i].number_of_times_killed;
         else
           if(saamps[i].color==BLUE1)
             blue_killed += saamps[i].number_of_times_killed;
         else
           if(saamps[i].color==YELLOW1)
             yellow_killed += saamps[i].number_of_times_killed;

      }
    int total_killed = 0 ;
    total_killed = red_killed + blue_killed + yellow_killed;
    if(total_killed>0)
   {
    x1 = XMAX+BARSIZE/2;
    x2 = x1 + 10;
    y1 = (YMAX+50)/2;
   
    y2 = (red_killed*200)/total_killed;
       
    grx_box(x1,YMENU+45,x2,y1,BLACK1);
    grx_box(x1,y1-y2,x2,y1,LIGHTRED1);

    x1 =  XMAX+3*BARSIZE/2;
    x2 = x1 + 10;
    y2 = (blue_killed*200)/total_killed;
   
   
    grx_box(x1,YMENU+45,x2,y1,BLACK1);
    grx_box(x1,y1-y2,x2,y1,BLUE1);


    x1 = XMAX+5*BARSIZE/2;
    x2 = x1 + 10;
       
    y2 = (yellow_killed*200)/total_killed;
    grx_box(x1,YMENU+45,x2,y1,BLACK1);
    grx_box(x1,y1-y2,x2,y1,YELLOW1);

    }
    red_killed = blue_killed = yellow_killed = 0;
    task_endcycle();
 }
}  

/*----------------------------------------------------------------------------------------*/
/*     Function to implement periodic task Prey             */
/*     Description : Checks for the presence of prey in the system. If
                     there is no prey it generates prey at random position                      
                     else moves the prey randomly till it is caught(killed) by the predator.
                     It uses function draw_prey to draw prey at new position.
/*----------------------------------------------------------------------------------------*/
 
TASK prey(void  *arg)
{
  TIME trand;
  trand = sys_gettime(NULL);
  srand(trand);

  while (1)
  {    
    if(chuha.isAlive  == 0)
    {
      int oldx,oldy;  
           
      oldx = chuha.x;
      oldy = chuha.y;
      chuha.x  = generateRandomNumber(XMIN,XMAX);
      chuha.y  = generateRandomNumber(YMIN,YMAX);
     
      draw_prey(oldx,oldy,chuha.x,chuha.y);
      chuha.isAlive = 1;
     
    }
   else
   {
     int tx,ty;
     tx = chuha.x;
     ty = chuha.y;
 
     if((chuha.x-PREY_RAD*5>XMIN) && (chuha.x+PREY_RAD*5<XMAX))
       chuha.x = generateRandomNumber(chuha.x-PREY_RAD*5,chuha.x+PREY_RAD*5);
     else
      if(chuha.x-PREY_RAD*5>XMIN)
       chuha.x = generateRandomNumber(chuha.x-PREY_RAD*5,chuha.x);
     else
     if(chuha.x+PREY_RAD*5<XMAX)
       chuha.x = generateRandomNumber(chuha.x,chuha.x+PREY_RAD*5);
   
    if((chuha.y-PREY_RAD*5>YMIN) && (chuha.y+PREY_RAD*5<YMAX))
       chuha.y = generateRandomNumber(chuha.y-PREY_RAD*5,chuha.y+PREY_RAD*5);
     else
      if(chuha.y-PREY_RAD*5>YMIN)
       chuha.y = generateRandomNumber(chuha.y-PREY_RAD*5,chuha.y);
     else
     if(chuha.y+PREY_RAD*5<YMAX)
       chuha.y = generateRandomNumber(chuha.y,chuha.y+PREY_RAD*5);
         
   draw_prey(tx,ty,chuha.x,chuha.y);
         
   }
    task_endcycle();
   }
}


/*----------------------------------------------------------------------------------------*/
/*     Function to implement task Predator             */
/*     Parameters  : Type of predator                  */
/*     Description : Creates new type(passed as argument)predator in the system. Then continuously
                     move towards prey.                      
                     Predator movement is governed by the fact that it has to avoid collision with
                     other peers in the prowl.
                     It uses function draw_saamp to draw predator at new position.

/*----------------------------------------------------------------------------------------*/


TASK saamp(void *arg)
{

  int     i =(int)arg;
  struct Saamp sam;
  int xs;
  int ys;
  int tempxs,tempys;
  int random;
 
  TIME trand;
 
  trand = sys_gettime(NULL);
  srand(trand);
  int ox,oy;
  int flag,gk;
  ox = sam.x  = generateRandomNumber(XMIN,XMAX);
  oy = sam.y  = generateRandomNumber(YMIN,YMAX);
  sem_wait(&grid_mutex);
  grid[(int)(sam.y/RATIO)-MAPPING][(int)(sam.x/RATIO)-MAPPING];
  sem_post(&grid_mutex);
  draw_saamp(ox,oy,sam.x,sam.y,GREEN1,saamps[i].color);
       
  saamps[i].x = sam.x;
  saamps[i].y = sam.y;
 
  while (1)
  {
   
     tempxs  = abs(sam.x - chuha.x);
     tempys  = abs(sam.y - chuha.y);
     if(tempxs<=(PREY_RAD+RAD) && tempys<=(PREY_RAD+RAD))
     {
        chuha.isAlive = 0;  
        saamps[i].number_of_times_killed++;                                
       
     }

     if(chuha.isAlive == 1)    
     {
     if(tempxs!=0 || tempys !=0)
     {
      if(sam.x!=chuha.x)
      {
        if(sam.x<chuha.x)
          sam.x++;
        else
          sam.x--;
      }  
      if(sam.y!=chuha.y)
      {
        if(sam.y<chuha.y)
          sam.y++;
        else
          sam.y--;             
      }
    }
  }
   
    sem_wait(&grid_mutex);
    gk=grid[(int)(sam.y/RATIO)-MAPPING][(int)(sam.x/RATIO)-MAPPING];
    sem_post(&grid_mutex);
   if(((int)(sam.y/RATIO)-MAPPING != (int)(oy/RATIO)-MAPPING) || ((int)(sam.x/RATIO)-MAPPING != (int)(ox/RATIO)-MAPPING))
   {
    if(gk==1)
   {
   int cnt =1;  
   
   while(gk==1)
   {
       
     if((sam.x-RATIO*cnt>XMIN) && (sam.x+RATIO*cnt<XMAX))
       sam.x = generateRandomNumber(sam.x-RATIO*cnt,sam.x+RATIO*cnt);
     else
      if(sam.x-RATIO*cnt>XMIN)
       sam.x = generateRandomNumber(sam.x-RATIO*cnt,sam.x);
     else
     if(sam.x+RATIO*cnt<XMAX)
       sam.x = generateRandomNumber(sam.x,sam.x+RATIO*cnt);
   
    if(sam.y-RATIO*cnt>YMIN && sam.y+RATIO*cnt<YMAX)
       sam.y = generateRandomNumber(sam.y-RATIO*cnt,sam.y+RATIO*cnt);
     else
      if(sam.y-RATIO*cnt>YMIN)
       sam.y = generateRandomNumber(sam.y-RATIO*cnt,sam.y);
     else
     if(sam.y+RATIO*cnt<YMAX)
       sam.y = generateRandomNumber(sam.y,sam.y+RATIO*cnt);
     cnt++;
     sem_wait(&grid_mutex);
     gk=grid[(int)(sam.y/RATIO)-MAPPING][(int)(sam.x/RATIO)-MAPPING];
     if(gk==0)
     {
      grid[(int)(sam.y/RATIO)-MAPPING][(int)(sam.x/RATIO)-MAPPING]=1;  
      grid[(int)(oy/RATIO)-MAPPING][(int)(ox/RATIO)-MAPPING]=0;
      draw_saamp(ox,oy,sam.x,sam.y,GREEN1,saamps[i].color);
     }
     sem_post(&grid_mutex);
     
    }

  }
  else
    {
     sem_wait(&grid_mutex);
     grid[(int)(sam.y/RATIO)-MAPPING][(int)(sam.x/RATIO)-MAPPING]=1;  
     grid[(int)(oy/RATIO)-MAPPING][(int)(ox/RATIO)-MAPPING]=0;
     draw_saamp(ox,oy,sam.x,sam.y,GREEN1,saamps[i].color);
     sem_post(&grid_mutex);
   }    
 
 }
   else
     {
     
       draw_saamp(ox,oy,sam.x,sam.y,GREEN1,saamps[i].color);
     }  


    saamps[i].x = sam.x;
    saamps[i].y = sam.y;
    ox = sam.x;
    oy = sam.y;
    task_endcycle();  
  }    
}


/*----------------------------------------------------------------------------------------*/
/*     Function called before system exits.                      */
/*     Description : Closes the graphical interface and exits using sys_end.*/

/*----------------------------------------------------------------------------------------*/

void ciao(void)
{
       grx_close();
       cputs("End of REPPOR Simulation");      
       return;
}
/*----------------------------------------------------------------------------------------*/
/*     Function called if Alt-x is pressed.                      */
/*     Description : Closes the graphical interface and exits using sys_end.*/

/*----------------------------------------------------------------------------------------*/

void end(KEY_EVT *evt)
{
        grx_close();
        cputs("End of REPPOR Simulation");     
        sys_end();
}

/*----------------------------------------------------------------------------------------*/
/*     Function to draw initial grid and scorecard      */

/*----------------------------------------------------------------------------------------*/

void make_rect()
{

    grx_box(XMIN-RAD-1, YMIN-RAD-1, XMAX+RAD+1, YMAX+RAD+1, GREEN);
   
    grx_text("Simulation of REPPOR", XMAX+5, YMENU+8, 13, 0);
    grx_text("R/B/Y create predator" , XMAX+5, YMENU+23, 12, 0);
    grx_text("Esc   exit to DOS"     , XMAX+5, YMENU+33, 12, 0);
    grx_rect(XMAX+YMENU,YMENU+43,620,(YMAX+50)/2,WHITE1);
    grx_text("Scores(% eaten)",XMAX+25,(YMAX+50)/2+15,11,BLACK1);
    grx_text("RED",XMAX+BARSIZE/2,(YMAX+50)/2+5,LIGHTRED1,0);
    grx_text("BLUE",XMAX+3*BARSIZE/2,(YMAX+50)/2+5,BLUE1,0);
    grx_text("YELLOW",XMAX+5*BARSIZE/2,(YMAX+50)/2+5,YELLOW1,0);
}
/*----------------------------------------------------------------------------------------*/
/*     Function to draw one kind of predator      */

/*----------------------------------------------------------------------------------------*/

void create_snake_red(HARD_TASK_MODEL m)
{
       saamps[number_of_tasks].color = LIGHTRED1;
       saamps[number_of_tasks].number_of_times_killed = 0;
       
       hard_task_default_model(m);
       hard_task_def_ctrl_jet (m);
       hard_task_def_arg      (m, (void *)number_of_tasks);
       hard_task_def_wcet     (m, sam_red_wcet);
       hard_task_def_mit      (m, sam_red_period);
       hard_task_def_group    (m, SNAKEGROUP);
       hard_task_def_usemath  (m);
     
       pid = task_create(SNAKE_R, saamp, &m, NULL);
       if (pid == NIL)  {
                  grx_close();
                  perror("Could not create task <saamp>");
                  sys_abort(1);
       }       
     task_activate(pid);
     number_of_tasks++;

 
}
/*----------------------------------------------------------------------------------------*/
/*     Function to draw one kind of predator      */

/*----------------------------------------------------------------------------------------*/

void create_snake_blue(HARD_TASK_MODEL m)
{    
     saamps[number_of_tasks].color = BLUE1;
     saamps[number_of_tasks].number_of_times_killed = 0;

     hard_task_default_model(m);
     hard_task_def_ctrl_jet (m);
     hard_task_def_arg      (m, (void *)number_of_tasks);
     hard_task_def_wcet     (m, sam_blue_wcet);
     hard_task_def_mit      (m, sam_blue_period);
     hard_task_def_group    (m, SNAKEGROUP);
     hard_task_def_usemath  (m);
     pid = task_create(SNAKE_B, saamp, &m, NULL);
     
     if (pid == NIL)  {
          grx_close();
          perror("Could not create task <saamp>");
          sys_abort(1);
     }
   task_activate(pid);
   number_of_tasks++;
       
}
/*----------------------------------------------------------------------------------------*/
/*     Function to draw one kind of predator      */

/*----------------------------------------------------------------------------------------*/

void create_snake_yellow(HARD_TASK_MODEL m){
       
       saamps[number_of_tasks].color = YELLOW1;
       saamps[number_of_tasks].number_of_times_killed = 0;

       hard_task_default_model(m);
       hard_task_def_ctrl_jet (m);
       hard_task_def_arg      (m, (void *)number_of_tasks);
       hard_task_def_wcet     (m, sam_yellow_wcet);
       hard_task_def_mit      (m, sam_yellow_period);
       hard_task_def_group    (m, SNAKEGROUP);
       hard_task_def_usemath  (m);
       pid = task_create(SNAKE_Y, saamp, &m, NULL);
       if (pid == NIL)  
       {
          grx_close();
          perror("Could not create task <saamp>");
          sys_abort(1);
        }
      task_activate(pid);
      number_of_tasks++;

}

/*--------------------------------------------------------------------------------------------------------*/
/*     Function main()                    */
/*     Description : Creates the environment for REPPOR simulation.It creates the playfield
                     and prey task. It also creates different types of predators based on user input.
                     It uses make_bargraph() and jet_task() functions to dipaly scorecard and system usage
                     parameters respectively.*/

/*--------------------------------------------------------------------------------------------------------*/
 
int main(int argc, char *argv[])
{

        HARD_TASK_MODEL m;
        HARD_TASK_MODEL m1;        
        SOFT_TASK_MODEL bar;
        SOFT_TASK_MODEL jet;        
        KEY_EVT key;
        int modenum;
        char c;
        int maxGridX=(XMAX-XMIN)/RATIO,maxGridY=(YMAX-YMIN)/RATIO,i,j; 

        sys_atrunlevel(ciao, NULL, RUNLEVEL_BEFORE_EXIT);
        sem_init(&grx_mutex,0,1);  
        sem_init(&grid_mutex,0,1);
       
         for(i=0;i<maxGridX;i++)
          for(j=0;j<maxGridY;j++)
            grid[i][j]=0;
                 
        /* graphic card Initialization */
       
        if (grx_init() < 1) {
          sys_abort(1);
        }
   
        if (grx_open(640, 480, 8) < 0) {
          cprintf("GRX Err\n");
          sys_abort(1);
        }
       
        key.ascii='x';
        key.scan=KEY_X;
        key.flag=ALTL_BIT;
        keyb_hook(key, end);           
        //Creation of playfield
        make_rect();
        hard_task_default_model(m1);
        hard_task_def_ctrl_jet(m1);
        hard_task_def_arg(m1, (void *)number_of_tasks);
        hard_task_def_wcet(m1, prey_wcet);
        hard_task_def_mit(m1, prey_period);    
        hard_task_def_usemath(m1);
        pid = task_create("Prey", prey, &m1, NULL);
        if (pid == NIL)
          {
            grx_close();
            perror("Could not create task <Prey>");
            sys_abort(1);
          }
          number_of_tasks++;    
          task_activate(pid);
          //Creation of Bar Graph
          soft_task_default_model(bar);
          soft_task_def_level(bar,1);
          soft_task_def_ctrl_jet(bar);
          soft_task_def_arg(bar, (void *)0);
          soft_task_def_met(bar, WCET_BARGRAPH);
          soft_task_def_period(bar,PERIOD_BARGRAPH);
          soft_task_def_usemath(bar);

          pid = task_create("BarGraph", make_bargraph, &bar, NULL);

          if (pid != NIL)
          {
            task_activate(pid);
            number_of_tasks++;
          }
 
          //Creation of jet task
        soft_task_default_model(jet);
        soft_task_def_level(jet,1);
        soft_task_def_arg(jet, (void *) 0);
        soft_task_def_met(jet, WCET_JET);
        soft_task_def_period(jet, PERIOD_JET);
        soft_task_def_usemath(jet);

        pid = task_create("JET", jet_task, &jet, NULL);
        if (pid != NIL){
                task_activate(pid);
                number_of_tasks++;
        }
             
      c  = keyb_getch(BLOCK);
      //Creation of predator tasks        
        do {
                 
          if ((number_of_tasks <= MAXTASKS))  
             switch(c)
             {
               case 'r':
               case 'R':
                 create_snake_red(m);            
                 break;
               case 'b':
               case 'B':
                 create_snake_blue(m);
                 break;
               case 'y':
               case 'Y':
                 create_snake_yellow(m);                 
                 break;
             default:
                    c = keyb_getch(BLOCK);  
                    continue;                          

             }
           c = keyb_getch(BLOCK);
        } while (c != ESC);
        grx_close();
        cputs("End of REPPOR Simulation");     
        sys_end();
        return 0;
}