gs_smart_app_pm.c

Go to the documentation of this file.

#include "config.h"
#ifdef GS_SMART_GRIDSOLVE
#include "grpc.h"
#include "gs_smart_stored_group_handles.h"
#include "gs_smart_app_pm_builder.h"


/*
 * Function creates the application performance model of a group of tasks based 
 * on the stored group of handles. 
 */

int gs_smart_generate_app_pm(grpc_function_handle_t ** handles_array, int ** blocking_array, int num_handles, gs_smart_app_pm * app_pm){
   int i;
  gs_argument_t *argptr;
  app_pm->nb_tasks=num_handles;
  if(app_pm->nb_tasks<0){
    ERRPRINTF("SMART: Error: incorrect value for nb_tasks or nb_rem_tasks\n");
    return -1;
  }
  app_pm->tasks= (gs_smart_app_pm_task **)calloc(app_pm->nb_tasks ,sizeof(gs_smart_app_pm_task *));
  if(!app_pm->tasks){
    ERRPRINTF("SMART: Failed to allocate memory for app_pm tasks\n");
    return -1;
  }
  for(i=0;i<app_pm->nb_tasks;i++){
    app_pm->tasks[i]=(gs_smart_app_pm_task *)calloc(1,sizeof(gs_smart_app_pm_task));
    if(!app_pm->tasks){
      ERRPRINTF("SMART: Failed to allocate memory for task %d of app_pm\n", i);
      return -1;
    }
    app_pm->tasks[i]->blocking=(int)blocking_array[i];
    app_pm->tasks[i]->local=0;
    app_pm->tasks[i]->nickname=handles_array[i]->problem_desc->name;  

    int nb_args=0;
    for(argptr= handles_array[i]->problem_desc->arglist;argptr!=NULL;argptr=argptr->next){
      nb_args++;
    }
    app_pm->tasks[i]->nb_args=nb_args;
    
    app_pm->tasks[i]->args= (gs_smart_app_pm_args **)calloc(app_pm->tasks[i]->nb_args ,sizeof(gs_smart_app_pm_args *));
    if(!app_pm->tasks[i]->args){
      ERRPRINTF("SMART: Failed to allocate memory for task arg\n");
      return -1;
    }
    int j;
    for(j=0;j<app_pm->tasks[i]->nb_args;j++){
      app_pm->tasks[i]->args[j]=(gs_smart_app_pm_args *)calloc(1,sizeof(gs_smart_app_pm_args));
      if(!app_pm->tasks[i]->args[j]){
        ERRPRINTF("SMART: Failed to allocate memory for task arg %d\n", j);
        return -1;
      }
    }
    j=0;
    for(argptr= handles_array[i]->problem_desc->arglist;argptr!=NULL;argptr=argptr->next){
      if(argptr->objecttype==0){
        app_pm->tasks[i]->args[j]->scalar=1;
      }
      else{
        app_pm->tasks[i]->args[j]->scalar=0;
      }
      if(argptr->objecttype==GS_SCALAR){
        if(argptr->datatype==GS_INT){
          app_pm->tasks[i]->args[j]->type=argptr->datatype;
          app_pm->tasks[i]->args[j]->uvalue.i=argptr->scalar_val.int_val;

        }
        else if(argptr->datatype==GS_DOUBLE){
          app_pm->tasks[i]->args[j]->type=argptr->datatype;
          app_pm->tasks[i]->args[j]->uvalue.d=argptr->scalar_val.double_val;
        }
        else if(argptr->datatype==GS_CHAR){
          app_pm->tasks[i]->args[j]->type=argptr->datatype;
          app_pm->tasks[i]->args[j]->uvalue.c=argptr->scalar_val.char_val;
        }
      }
      if(!app_pm->tasks[i]->args[j]->scalar){
        app_pm->tasks[i]->args[j]->id=(int)argptr->data;
      }
      else{
         app_pm->tasks[i]->args[j]->id=-1;
      }
      j++;
    }

  }
  return 0;
  
}  


/*
 * Function frees  the application performance model 
 */

int
gs_smart_app_pm_free(gs_smart_app_pm *app_pm)
{
  gs_smart_app_pm_args * arg;
  int i, j;
 
  if(!app_pm){
    ERRPRINTF("SMART: Error freeing application performance model\n");
    return -1;
  }
  for(i=0;i<app_pm->nb_tasks;i++){
    for(j=0;j<app_pm->tasks[i]->nb_args;j++){
      arg=app_pm->tasks[i]->args[j];
      if(arg->a_anayl) free(arg->a_anayl);
      if(arg) free(arg);
    }

    if(app_pm->tasks[i]->args) free(app_pm->tasks[i]->args);
    if(app_pm->tasks[i]->t_anayl) free(app_pm->tasks[i]->t_anayl);
    if(app_pm->tasks[i]) free(app_pm->tasks[i]);
  }

  if(app_pm->tasks) free(app_pm->tasks);
    
  if(app_pm) free(app_pm);
  return 0;
}



/*
 * Function adds a handle to the stored group of handles
 */


int gs_smart_store_handle(grpc_function_handle_t * handle,  grpc_sessionid_t * sessionId , gs_va_list * argptr, int blocking, int lang, char major, int map_group_type){

  /*
   * if the user  has not explicitly specified the number of tasks to map
   * the handle array size is unknown. Therefore the array storage size must 
   * be constantaly adjusted 
   * We are adjusting the array size every time a new task handle is called
   * 
   * when the user has explicitly specified the number of tasks to map, the storage for the handle arrays 
   * have already been alloc'd.
   * therefore the handle array storage does not need to be adjusted.
   */
  if(map_group_type==GS_SMART_IMPLICIT_GROUP){
    if(gs_smart_adjust_handle_array_sizes()<0){
      ERRPRINTF("SMART Error: Error adjusting handle array sizes\n");
      return -1;
    }
  }
  
  /*
   * storing this task handle,its session id and whether it's a blocking or non-blocking task
   */ 
  handles_array[handle_array_pos]=handle;
  blocking_array[handle_array_pos]=blocking;
  session_ids[handle_array_pos]=sessionId;

 
  /*
   * this function retrieves the IDL information for each handle
   * ToDo: Retrieve all the IDL information for all the handles at the same time
   * just before mapping
   */ 
  if(gs_sender_compute_arg_sizes(argptr, NULL,  handles_array[handle_array_pos]->problem_desc, lang, major) < 0){
    ERRPRINTF("SMART : Error computing arg sizes\n");
    return -1;
  }

  /*
   * the handle_array_pos variable keeps track of the position of the last handle
   * stored in the the handle array. therefore everytime a handle is added, this variable
   * needs to be incremented
   */ 
  handle_array_pos++;
  return 0;
}



/*
 * If the array storing the group of handles is not sufficient
 * size to store the next handle then this function increases 
 * its size by 1.
 */

int gs_smart_adjust_handle_array_sizes(){
  
  /*
   * if the current build index, which keeps track of the position of the last handle
   * stored in the handle array is greater than or equal to the current handle array
   * size then we need to increase the size of the handle array.
   */
  if(handle_array_pos==0){
   handles_array=(grpc_function_handle_t  **)calloc(1, sizeof(grpc_function_handle_t  *));  

   session_ids = (grpc_sessionid_t **)calloc(1 , sizeof(grpc_sessionid_t *));
   blocking_array=(int *)calloc(1 , sizeof(int));
   handle_array_size++;
  }
  else if(handle_array_pos>=handle_array_size){
   handles_array=(grpc_function_handle_t  **)realloc(handles_array , sizeof(grpc_function_handle_t  *) *  (handle_array_size+1));  
   session_ids = (grpc_sessionid_t **)realloc(session_ids , sizeof(grpc_sessionid_t *) * (handle_array_size+1));
   blocking_array=(int *)realloc(blocking_array , sizeof(int)* (handle_array_size+1));
   handle_array_size++;
  } 

  return 0;
}

/*
 * Function return the stored group of handles, their session id, the array indicating 
 * whether they are blocking and the number of tasks stored.
 */

int gs_smart_get_handle_list(grpc_function_handle_t ***handle,  grpc_sessionid_t *** sessionId, int *** _blocking_array, int * nb_tasks){
  *sessionId=session_ids;
  *_blocking_array= (int **)blocking_array;
  *handle=handles_array;
  *nb_tasks=handle_array_size;
  return 0;
}



/*
 * Function return the number of tasks left to store in
 * handle array. This is used when the number of tasks
 * to map has been explicitly specified by the application programmer.
 */

int gs_smart_get_nb_auto_tasks_left_to_build(){
  return (handle_array_size-handle_array_pos);
}

int gs_smart_free_handle_list(){

 // int i;
  free(blocking_array);
  free(handles_array);
  free(session_ids);
  handle_array_size=0;
  handle_array_pos=0;
  return 0;
}

#endif