gs_smart_mapping_graph.c

Go to the documentation of this file.

#include "config.h"
#ifdef GS_SMART_GRIDSOLVE
#include "gs_smart_mapping_graph.h"
#include "gs_smart_mapping_heuristics.h"
#include "gs_smart_task_graph.h"
#include "gs_smart_netpm.h"
#include "comm_data.h"
#include "gs_smart_app_pm.h"
#include "gs_smart_mapping_solution.h"
#include "math.h"

int
gs_smart_map_common(char * input_mapper_type,  gs_smart_tg * tg, 
                  gs_smart_netpm * netpm, int * total_nb_mapped_tasks){

  int i, mapper_found=0;
  if( (!input_mapper_type) || (!tg) || (!netpm) ) return -1;

  best_mg= (gs_smart_mg * )calloc(1, sizeof(gs_smart_mg));
  if(!best_mg) return -1;
  
  for(i=0;i<gs_smart_get_nb_mappers(); i++){
    if(strcmp(gs_smart_get_mapping_name(i), input_mapper_type)==0){
      if(gs_smart_exec_mapper(tg, netpm, &best_mg, i)<0){
        ERRPRINTF("SMART : Error performing mapping heuristic %s\n", input_mapper_type);
        return -1;
      }
      mapper_found=1;
    }
  }

/*
 
  if(gs_smart_mg_print_to_dotgraph(best_mg, "smart_graphs/best_map_graph.dot")<0){
      ERRPRINTF("SMART : Error printing dotgraph\n ");
      return -1;
    }
    system("dot -Tjpg smart_graphs/best_map_graph.dot -o smart_graphs/best_map_graph.jpg");
*/



  if(mapper_found==0){
    ERRPRINTF("SMART: Unknown mapper\n");
    return -1;
  }
  *total_nb_mapped_tasks=best_mg->nb_mg_rem_nodes;
  return 0;
}





int gs_smart_generate_mapping_graph(gs_smart_tg * tg, gs_smart_netpm * netpm, 
                                          int * mapping_vec, gs_smart_mg *mg, int * _valid_graph){

  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_mg_task_node * mg_task_node=NULL;
  gs_smart_mg_node * mg_node;
  gs_smart_mg_obj_node * mg_obj_node;
  int i, j, k;
  int mg_nb_obj_for_links, sent_remotely;
  int tg_nb_obj_for_links;
  int this_mg_o_f_link_cnt, next_mg_o_f_link_cnt;
  int valid_graph;

  if( (!tg) || (!netpm) || (!mapping_vec) ) return -1;

  *_valid_graph=1;

  if(gs_smart_mg_construct_frame(tg, netpm, mapping_vec, mg, &valid_graph)<0){
    ERRPRINTF("SMART : Error constructing mapping graph frame\n");
    return -1;
  }

  if(!mg) return -1;

  if(!valid_graph){
    *_valid_graph=valid_graph;
    return 0;
  }
  for(i=0;i<mg->nb_mg_nodes;i++){
    if(!mg->mg_nodes[i]) return -1;
    mg_node=mg->mg_nodes[i];   
    if(mg_node->node_type==GS_SMART_MG_TASK_NODE){
      if(!mg_node->mg_task_node) return -1;
      mg_task_node=mg_node->mg_task_node;
      if(!tg->task_nodes[i]) return -1;
      if(!tg->task_nodes[i]->tg_rem_task_node) return -1;
      tg_rem_task_node=tg->task_nodes[i]->tg_rem_task_node;
      for(j=0;j<mg_task_node->nb_back_links;j++){
        if(!mg_task_node->back_link_set) return -1;
        /*
         * Set the back link object nodes that have not already been set.
         * Back link object nodes could be other tasks forward link object nodes
         * when there is a dependency and are therefore set when setting forward
         * link object nodes.
         */ 
        if(mg_task_node->back_link_set[j]==0){

          /*
           * Counts the number of object forward links of object node
           * on the end of back links from task nodes.
           */ 
          if(gs_smart_mg_count_c_comm_for_obj_links(tg, netpm, mg,i, j, 
                                       &mg_nb_obj_for_links, &sent_remotely)<0){
            ERRPRINTF("SMART : Error counting task %d  object node %d for links\n", i, j);
            return -1;
          }


          /*
           * Constructs back link object nodes and points them to the previous
           * client.
           */ 
          if(gs_smart_mg_construct_c_comm_obj_back_links(tg, netpm,mg, i, j, mg_nb_obj_for_links)<0){
            ERRPRINTF("SMART : Error constructing task backward links\n");
            return -1;
          }
          if(!mg_task_node->mg_node_back_links) return -1;
          if(!mg_task_node->mg_node_back_links[j]) return -1;
          if(!mg_task_node->mg_node_back_links[j]->mg_obj_node_ptr) return -1;
          mg_obj_node=mg_task_node->mg_node_back_links[j]->mg_obj_node_ptr;          
          mg_obj_node->sent_remotely=sent_remotely;

          if(!mg_obj_node->mapped_obj_node) return -1;
          if(!mg_obj_node->mapped_obj_node->nb_obj_frwd_links) return -1;
          tg_nb_obj_for_links=mg_obj_node->mapped_obj_node->nb_obj_frwd_links;
          this_mg_o_f_link_cnt=1;
          k=1;
          for(k=1;((k<tg_nb_obj_for_links) && ( this_mg_o_f_link_cnt<mg_nb_obj_for_links)) ;k++){
            /*
             * Points each for obj link of the back link's obj node 
             * to the destination nodes.  The back link of the destination node
             * is connected to the obj for link and the element of back_link_set array 
             * corresponding to the back link is set to one.  This ensures
             * that that back link is not set again.
             */ 
             if(gs_smart_mg_set_c_comm_dep(tg, netpm,mg, i, j, k, this_mg_o_f_link_cnt, &next_mg_o_f_link_cnt)<0){
               ERRPRINTF("SMART : Error constructing task backward links\n");
               return -1;
             }
             this_mg_o_f_link_cnt=next_mg_o_f_link_cnt;
          }

        }
      }

      for(j=0;j<mg_task_node->nb_for_links;j++){
        if(!mg_task_node->mg_node_for_links) return -1;
        if(!mg_task_node->mg_node_for_links[j]) return -1;
        if(!mg_task_node->mg_node_for_links[j]->mg_obj_node_ptr) return -1;

        mg_obj_node=mg_task_node->mg_node_for_links[j]->mg_obj_node_ptr;
        /*
         * Counts the number of object forward links of object node
         * on the end of forward links from task nodes.
         */ 
        if(gs_smart_mg_count_s_comm_for_obj_links(tg, netpm, mg,i, j, 
                                       &mg_nb_obj_for_links, &sent_remotely)<0){
          ERRPRINTF("SMART : Error counting task %d  object node %d for links\n", i, j);
          return -1;
       }

       /*
        * Constructs forward link object nodes and points back to the task.
        */ 

       if(gs_smart_mg_construct_s_comm_obj_for_links(tg,netpm, mg, i, j, mg_nb_obj_for_links)<0){
         ERRPRINTF("SMART : Error constructing smart task forward links\n");
         return -1;
       }
       mg_obj_node->sent_remotely=sent_remotely;


       tg_nb_obj_for_links=mg_obj_node->mapped_obj_node->nb_obj_frwd_links;
       this_mg_o_f_link_cnt=0;

       for(k=0;((k<tg_nb_obj_for_links) && ( this_mg_o_f_link_cnt<mg_nb_obj_for_links)) ;k++){
         /*
          * Points each for obj link of the tasks forward link's obj node 
          * to the destination nodes.  The back link of the destination node
          * is connected to the object forward link and the element of back_link_set array 
          * corresponding to the back link is set to one.  This ensures
          * that that back link is not set again.
          */ 
         if(gs_smart_mg_set_s_comm(tg, netpm, mg,  i, j, k, this_mg_o_f_link_cnt, &next_mg_o_f_link_cnt)<0){
           ERRPRINTF("SMART : Error setting obj for link dependency of task %d for link %d\n", i, j);
           return -1;
         }
         this_mg_o_f_link_cnt=next_mg_o_f_link_cnt;
       }
      }
    }
  }
  for(i=0;i<netpm->nb_nodes;i++){
    netpm->netpm_nodes[i]->server->task_workload=0;
  }
  return 0;
}


/*
 *    This function creates a mapping task node for each task node in the 
 *    task graph (tg) and a client map node for every client node in the 
 *    task graph. It assigns the node of the network performance model(netpm_node) 
 *    which is outlined in the vector (mapping vec) to each task map node.
 *    In this function each task map node (which specifies a task node 
 *    to netpm node assignment) in the mapping graph is also timed.
 *    In addition the forward links, the object nodes and back links of the 
 *    mapping task nodes are created.
 *   
 *    
 *    @param tg - (in) Task Graph of a group of tasks 
 *    @param netpm -- (in) Network performance model
 *    @param mapping_vec -- (in) Mapping vec which outlines the task to
 *    server assignment
 *    @param mg -- (out) mapping graph
 *    @param valid_graph -- (out) 0 if mg is not a valid solution
 *    
 *    @returns -1 if there is an error
 *
 */


int gs_smart_mg_construct_frame(gs_smart_tg * tg, gs_smart_netpm * netpm, 
                      int * mapping_vec,gs_smart_mg *mg, int *valid_graph){

  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_tg_client_node * tg_client_node;
  gs_smart_netpm_node * netpm_node;
  gs_smart_mg_task_node * mg_task_node=NULL;
  gs_smart_mg_client_node * mg_client_node;
  gs_smart_mg_link * mg_for_link;
  gs_smart_mg_obj_node * mg_obj_node;
  int i, j, map_vec_pos, server_pos;
  int valid_assignment=0;
  int timing_nbl_tasks=0;
  double exe_time;
  double max_time_nbl_tasks=0.0;
  
  if( (!tg) || (!netpm) || (!mapping_vec) ) return -1;

  *valid_graph=1;
  mg->total_time=0.0;
  mg->nb_mg_nodes=tg->nb_nodes;
  mg->nb_mg_rem_nodes=tg->nb_rem_nodes;
  mg->mg_nodes=(gs_smart_mg_node **)
                calloc(mg->nb_mg_nodes, sizeof(gs_smart_mg_node *));
  if(!mg->mg_nodes) return -1;
  map_vec_pos=0;
  for(i=0;i<mg->nb_mg_nodes;i++){
    mg->mg_nodes[i]=(gs_smart_mg_node *)calloc(1, sizeof(gs_smart_mg_node ));
    if(!mg->mg_nodes[i]) return -1;
    mg->mg_nodes[i]->id=i;
    if(tg->task_nodes[i]->node_type==GS_SMART_TG_START_NODE){
     /*
      * First node is a start node
      */ 
      mg->mg_nodes[i]->node_type=GS_SMART_MG_START_NODE;
    }
    else if(tg->task_nodes[i]->node_type==GS_SMART_TG_REM_TASK_NODE){
     /*
      *  Create a mapping task node
      */  
      server_pos=mapping_vec[map_vec_pos];
      mg->mg_nodes[i]->node_type=GS_SMART_MG_TASK_NODE;
      mg->mg_nodes[i]->mg_task_node=(gs_smart_mg_task_node *)
                                      calloc(1, sizeof(gs_smart_mg_task_node));

      if(!mg->mg_nodes[i]->mg_task_node) return -1;

      /*
       * Assign a netpm node to the mapping task node
       * which is outlined in mapping_vec
       */ 
      if(!mg->mg_nodes[i]->mg_task_node) return -1;
      mg_task_node=mg->mg_nodes[i]->mg_task_node;

      if(!tg->task_nodes) return -1;
      if(!tg->task_nodes[i]) return -1;
      if(!tg->task_nodes[i]->tg_rem_task_node) return -1;
      tg_rem_task_node=tg->task_nodes[i]->tg_rem_task_node;
      mg_task_node->mapped_task_node=tg_rem_task_node;
 
      if(!netpm->netpm_nodes) return -1;
      if(!netpm->netpm_nodes[server_pos]) return -1;
      netpm_node=netpm->netpm_nodes[server_pos];
      mg_task_node->mapped_server_node=netpm_node;


      valid_assignment=0;
   
      /*
       * Check if the assignment if task node to netpm node is valid
       */ 
      if(gs_smart_check_if_valid_assignment(mg_task_node->mapped_task_node, 
              mg_task_node->mapped_server_node->server, &valid_assignment)<0){

        ERRPRINTF("SMART: Error checking if task to server assignment valid\n");
        return -1;
      }

      /*
       * If it is not valid return with valid_graph=0.
       */ 
    
      if(!valid_assignment){

        *valid_graph=0;
        return 0;
      }
 
     /*
      * Time this mapping task node
      */
      if(gs_smart_time_mg_task_node(mg_task_node, &exe_time)<0){
        ERRPRINTF("SMART: Error estimated exection time of task node\n");
        return -1;
      } 

      mg_task_node->time=exe_time;


     /*
      * If this mapping task node is a non-blocking task increase the 
      * task workload of the netpm server node which has been assigned 
      * this task.
      *
      * Also check if it is non-blocking check to see if this task
      * has the highest execution time of the group of non-blocking tasks.
      * For a group of non blocking tasks only the nonblocking task with
      * the highest execution time will contribute to the accumulated 
      * mapping graph's execution time.
      * 
      */    
 
     if( mg_task_node->mapped_task_node->blocking==0){
        if(timing_nbl_tasks==0){
          max_time_nbl_tasks=mg_task_node->time;
        
          if(!netpm_node->server) return -1;

        }
        netpm_node->server->task_workload =(netpm_node->server->task_workload+
                                                  ((( mg_task_node->time/100 )+10)));
      //  LOGPRINTF("THE TASK WORKLOAD FOR SERVER %s IS %d\n", netpm_node->server->hostname, netpm_node->server->task_workload);
        timing_nbl_tasks=1;
      }
      if(timing_nbl_tasks==1){
        if(mg_task_node->time>max_time_nbl_tasks){
          max_time_nbl_tasks=mg_task_node->time;
        }
      }  
     
      /*
       * If this is the first blocking task at the end of a
       * group of non-blocking tasks, then reset task workload of each
       * server netpm node.  This blocking task will also be executed
       * in parallel with the group of non-blocking tasks therefore
       * if its execution time is higher than the execution time of the 
       * group of non-blocking tasks then this will be the execution time that will contribute to
       * accumulated mapping graph's execution time.
       * 
       */ 

      if((mg_task_node->mapped_task_node->blocking==1) && (timing_nbl_tasks==1)){
        mg->total_time=max_time_nbl_tasks+mg->total_time;
        for(j=0;j<netpm->nb_nodes;j++){
          if(!netpm->netpm_nodes) return -1;
          if(!netpm->netpm_nodes[j]) return -1;
          if(!netpm->netpm_nodes[j]->server) return -1;
          netpm->netpm_nodes[j]->server->task_workload=0;
        }
        max_time_nbl_tasks=0;
        timing_nbl_tasks=0;
      }

      /*
       * Time a blocking graph which is not at the end of a non-blocking group of tasks
       */
      else if((mg_task_node->mapped_task_node->blocking==1) && (timing_nbl_tasks==0)){
        mg->total_time=mg_task_node->time+mg->total_time;
        for(j=0;j<netpm->nb_nodes;j++){
          if(!netpm->netpm_nodes) return -1;
          if(!netpm->netpm_nodes[j]) return -1;
          if(!netpm->netpm_nodes[j]->server) return -1;
          netpm->netpm_nodes[j]->server->task_workload=0;
        }
        timing_nbl_tasks=0;
      }

      /*
       * Set up forward task links of mapping task node and
       * create mapping object nodes. 
       *
       */ 


      mg_task_node->nb_for_links=tg_rem_task_node->nb_node_frwd_links; 
      mg_task_node->mg_node_for_links=(gs_smart_mg_link **)
                        calloc(mg_task_node->nb_for_links, sizeof(gs_smart_mg_link *));

      if(!mg_task_node->mg_node_for_links) return -1;

      for(j=0; j<mg_task_node->nb_for_links; j++){
        mg_task_node->mg_node_for_links[j]=(gs_smart_mg_link *)
                                               calloc(1, sizeof(gs_smart_mg_link ));
        
        if(!mg_task_node->mg_node_for_links[j]) return -1;
        mg_for_link=mg_task_node->mg_node_for_links[j];
        mg_for_link->for_link_pos=j; 

        /*
         * Point link back to mapping task node
         */   
        mg_for_link->mg_node_ptr=mg->mg_nodes[i];

        mg_for_link->mg_obj_node_ptr=(gs_smart_mg_obj_node *)calloc(1, sizeof(gs_smart_mg_obj_node));
 
        if(!mg_for_link->mg_obj_node_ptr) return -1;

        mg_obj_node=mg_for_link->mg_obj_node_ptr;

        /*
         * Assign task object node to mapping object node
         */ 
        
        if(!tg_rem_task_node->tg_node_frwrd_link) return -1;
        if(!tg_rem_task_node->tg_node_frwrd_link[j]) return -1;
        if(!tg_rem_task_node->tg_node_frwrd_link[j]->obj_node_ptr) return -1;
        mg_obj_node->mapped_obj_node=tg_rem_task_node->tg_node_frwrd_link[j]->obj_node_ptr;
      }


      /*
       * Setup back task links of mapping task node 
       */ 
      mg_task_node->nb_back_links=tg_rem_task_node->nb_node_bkwd_links; 
      mg_task_node->mg_node_back_links=(gs_smart_mg_link **)
                        calloc(mg_task_node->nb_back_links, sizeof(gs_smart_mg_link *));


      if(!mg_task_node->mg_node_back_links) return -1;
      mg_task_node->back_link_set=(int *)
                        calloc(mg_task_node->nb_back_links, sizeof(int));

      if(!mg_task_node->back_link_set) return -1;
      map_vec_pos++;
    }

    /*
     * Set up client mapping node
     */ 
    else if(tg->task_nodes[i]->node_type==GS_SMART_TG_CLIENT_NODE){
      mg->mg_nodes[i]->node_type=GS_SMART_MG_CLIENT_NODE;
      mg->mg_nodes[i]->mg_client_node=(gs_smart_mg_client_node *)
                                      calloc(1, sizeof(gs_smart_mg_client_node));


      if(!mg->mg_nodes[i]->mg_client_node) return -1;
      mg_client_node=mg->mg_nodes[i]->mg_client_node;
      
      tg_client_node=tg->task_nodes[i]->tg_client_node;
      mg_client_node->mapped_client_node=tg_client_node;      
            
     }
    /*
     * Set up end mapping node
     */ 

    else if(tg->task_nodes[i]->node_type==GS_SMART_TG_END_NODE){
      mg->total_time=max_time_nbl_tasks+mg->total_time;
      mg->mg_nodes[i]->node_type=GS_SMART_MG_END_NODE;
    }
  }
  return 0;
}




int gs_smart_mg_count_c_comm_for_obj_links(gs_smart_tg * tg, gs_smart_netpm * netpm,
                                    gs_smart_mg *mg, int task_id, 
                                 int back_link_id, int * _mg_nb_obj_for_links, int * _sent_remotely){
  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_mg_node * mg_node;
  gs_smart_mg_task_node * mg_task_node=NULL, * mg_dest_task_node=NULL;
  gs_smart_mg_link  * mg_back_link;
  gs_smart_tg_obj_node * tg_obj_node; 
  gs_smart_tg_task_node * tg_dest_task_node;

  int j,k;
  int tg_nb_obj_for_links, mg_nb_obj_for_links;
  int dest_task_id;
  int sent_remotely=0;

  j=back_link_id;
 
  mg_node=mg->mg_nodes[task_id];
   
  mg_task_node=mg_node->mg_task_node;
  tg_rem_task_node=tg->task_nodes[task_id]->tg_rem_task_node;

  mg_back_link=mg_task_node->mg_node_back_links[j];
  /*  
   * If tg obj node point back to the previous client,
   * then the mg_obj_node should only have one forward link
   * which points to the next task node.
   */ 
  tg_obj_node=tg_rem_task_node->tg_node_bkwrd_link[j]->obj_node_ptr;
  gs_smart_tg_task_node * tg_back_link_node=tg_obj_node->tg_obj_bkwrd_link->task_node_ptr;
  if(tg_back_link_node->id!=task_id-1){
    *_mg_nb_obj_for_links=1;
    *_sent_remotely=0;
    return 0;
  }
  

  tg_nb_obj_for_links=tg_rem_task_node->tg_node_bkwrd_link[j]->obj_node_ptr->nb_obj_frwd_links;
  mg_nb_obj_for_links=tg_nb_obj_for_links;
  k=1;
  for(k=1; k<tg_nb_obj_for_links;k++){
    tg_obj_node=tg_rem_task_node->tg_node_bkwrd_link[j]->obj_node_ptr;
    tg_dest_task_node=tg_obj_node->tg_obj_frwrd_link[k]->task_node_ptr;
    dest_task_id=tg_dest_task_node->id;
    if(mg->mg_nodes[dest_task_id]->node_type==GS_SMART_MG_TASK_NODE){
      mg_dest_task_node=mg->mg_nodes[dest_task_id]->mg_task_node;
      if(mg_dest_task_node->mapped_server_node->server->smart==0){
       *_mg_nb_obj_for_links=1;
       *_sent_remotely=0;
       return 0;
      }
    }
  }
  if(tg_nb_obj_for_links>1){
    sent_remotely=1;
  }
  *_mg_nb_obj_for_links=mg_nb_obj_for_links;
  *_sent_remotely=sent_remotely;
  return 0;
}













/*
 *    This function constructs the back links from the mapping task node.
 *    It also creates the object nodes that these back links point to and
 *    the forward links that eminate from these object nodes..
 *    Each back link is also timed and this is added to the total accumulated
 *    mapping graph time.
 *   
 *    
 *    @param tg - (in) Task Graph of a group of tasks 
 *    @param netpm -- (in) Network performance model
 *    server assignment
 *    @param mg -- (inout) mapping graph
 *    @param task_id -- (in) specifies which mapping node to construct 
 *    back links for.
 *    @param back_link_pos - (in) specifies which back link to construct
 *    @param mg_nb_obj_for_links - (in) specifies nb object for links 
 *    which eminate from the back links object node.
 *    
 *    @returns -1 if there is an error
 *
 */



int gs_smart_mg_construct_c_comm_obj_back_links(gs_smart_tg * tg, gs_smart_netpm * netpm,
                                          gs_smart_mg *mg, int task_id, int back_link_pos, 
                                                                 int mg_nb_obj_for_links){

  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_tg_obj_node * tg_obj_node;
  gs_smart_mg_node * mg_node;
  gs_smart_mg_task_node * mg_task_node=NULL;
  gs_smart_mg_link  * mg_back_link;
  gs_smart_netpm_node * netpm_node;
  gs_smart_mg_obj_node * mg_obj_node;  
  double bw;
  int byte_size;
  if(!mg->mg_nodes[task_id]) return -1;
  mg_node=mg->mg_nodes[task_id];
  mg_task_node=mg_node->mg_task_node;

  if(!mg_task_node->mapped_server_node) return -1;
  netpm_node=mg_task_node->mapped_server_node;
  
  if(!tg->task_nodes) return -1;
  if(!tg->task_nodes[task_id]) return -1;
  if(!tg->task_nodes[task_id]->tg_rem_task_node) return -1;
  tg_rem_task_node=tg->task_nodes[task_id]->tg_rem_task_node;
   

  if(!mg_task_node->mg_node_back_links) return -1;
  mg_task_node->mg_node_back_links[back_link_pos]=(gs_smart_mg_link *)
                                             calloc(1, sizeof(gs_smart_mg_link ));
        

  
  /*
   * Creating the back link object node and pointing the back link to it
   */
  if(!mg_task_node->mg_node_back_links[back_link_pos]) return -1;
  mg_back_link=mg_task_node->mg_node_back_links[back_link_pos];
  mg_back_link->back_link_pos=back_link_pos; 
  if(!mg->mg_nodes[task_id]) return -1;

  mg_back_link->mg_node_ptr=mg->mg_nodes[task_id];
  mg_back_link->mg_obj_node_ptr=(gs_smart_mg_obj_node *)
                                       calloc(1, sizeof(gs_smart_mg_obj_node));
  if(!mg_back_link->mg_obj_node_ptr) return -1;

  /*
   * Setting the obj node which that back link points to.
   * Assigning the object node of the task graph which 
   * corresponds to this mapping object node 
   */ 
  mg_obj_node = mg_back_link->mg_obj_node_ptr;

  if(!tg_rem_task_node->tg_node_bkwrd_link) return -1;
  if(!tg_rem_task_node->tg_node_bkwrd_link[back_link_pos]) return -1;
  if(!tg_rem_task_node->tg_node_bkwrd_link[back_link_pos]->obj_node_ptr) return -1;
  tg_obj_node=tg_rem_task_node->tg_node_bkwrd_link[back_link_pos]->obj_node_ptr;


  mg_obj_node->mapped_obj_node=tg_obj_node;

  
 /*
  * Assigning the network link of the network performance model
  * that corresponds to this backtg_rem_task_node->tg_node_bkwrd_link[j]->obj_node_ptr link.
  */
  if(!netpm_node->netpm_links) return -1;
  if(!netpm_node->netpm_links[0]) return -1;
  mg_back_link->mapped_netpm_link=netpm_node->netpm_links[0];


  /*
   *
   * Find the bandwidth of the netpm link which corresponds
   * to this back links
   */ 

  if(netpm_node->netpm_links[0]->bw==0){
    netpm_node->netpm_links[0]->bw=netpm->avg_c_bw;
  }
  bw=netpm_node->netpm_links[0]->bw;
  byte_size=mg_obj_node->mapped_obj_node->byte_size;


 /*
  * Calculate time for this backlink and add it 
  * to the accumulated total time of mapping graph.
  */ 
  mg_back_link->time=(double)((byte_size/bw));
  mg->total_time=mg_back_link->time+mg->total_time;

  /*
   * Set the back link set array corresponding to this
   * back link to 1 so that this back link does not get
   * set again.
   */ 
  if(!mg_task_node->back_link_set) return -1;
  mg_task_node->back_link_set[back_link_pos]=1;


  /*  
   * If this does not point back to the previous client,
   * then the mg_obj_node should only have one forward link
   * point to the next task node.
   */ 

   gs_smart_tg_task_node * tg_back_link_node=tg_obj_node->tg_obj_bkwrd_link->task_node_ptr;
   if(tg_back_link_node->id!=task_id-1){
      mg_obj_node->nb_for_links=1;
   }
   else{
     mg_obj_node->nb_for_links=mg_nb_obj_for_links;
   }


  /*
   * Setting forward link from obj node to be the same as
   * back link of next task node.  Also assigning netpm
   * link to forward object link of object node.
   */ 
  mg_obj_node->mg_obj_for_links=(gs_smart_mg_link **)calloc(mg_obj_node->nb_for_links, sizeof(gs_smart_mg_link *)); 
  if(!mg_obj_node->mg_obj_for_links) return -1;

  mg_obj_node->mg_obj_for_links[0]=mg_back_link;


  /*
   * Setting back link from obj node to client node
   */ 
  mg_obj_node->mg_obj_back_link=(gs_smart_mg_link *)
                                       calloc(1, sizeof(gs_smart_mg_link));

  if(!mg_obj_node->mg_obj_back_link) return -1;
  if(!mg->mg_nodes[task_id-1]) return -1;
  mg_obj_node->mg_obj_back_link->mg_node_ptr=mg->mg_nodes[task_id-1];
  mg_obj_node->mg_obj_back_link->mg_obj_node_ptr=mg_obj_node;

  return 0;
}





int gs_smart_mg_set_c_comm_dep(gs_smart_tg * tg, gs_smart_netpm * netpm,
                           gs_smart_mg *mg, int task_id, int back_link_pos,int for_obj_link_pos,
                                 int mg_this_o_f_link_cnt, int * mg_next_o_f_link_cnt){

  int dest_task_id;
  int dest_back_link_pos;
  gs_smart_tg_obj_node * tg_obj_node;
  gs_smart_mg_node * mg_dest_node;
  gs_smart_mg_task_node * mg_dest_task_node;
  gs_smart_mg_link *mg_for_link, * mg_dest_back_link;
  gs_smart_mg_node * mg_node;
  gs_smart_mg_task_node * mg_task_node=NULL;
  gs_smart_mg_link * mg_back_link, * mg_obj_back_link;
  gs_smart_mg_obj_node * mg_obj_node;
  gs_smart_netpm_node * netpm_node;
  double bw;
  int byte_size;


  mg_node=mg->mg_nodes[task_id];
  mg_task_node=mg_node->mg_task_node;

  mg_back_link=mg_task_node->mg_node_back_links[back_link_pos];
  mg_obj_node = mg_back_link->mg_obj_node_ptr;


  /*
   * Setting client obj for links
   */ 
  mg_obj_node->mg_obj_for_links[mg_this_o_f_link_cnt]=
                             (gs_smart_mg_link *)calloc(1, sizeof(gs_smart_mg_link ));

  mg_for_link= mg_obj_node->mg_obj_for_links[mg_this_o_f_link_cnt];
  mg_for_link->for_link_pos=mg_this_o_f_link_cnt;

  /*
   * Finding destination node for obj for link
   */
  tg_obj_node=mg_obj_node->mapped_obj_node;
  dest_task_id=tg_obj_node->tg_obj_frwrd_link[for_obj_link_pos]->task_node_ptr->id;
  dest_back_link_pos=tg_obj_node->tg_obj_frwrd_link[for_obj_link_pos]->back_link_pos;

  mg_dest_node=mg->mg_nodes[dest_task_id];


  mg_dest_task_node=mg_dest_node->mg_task_node;

  netpm_node=mg_dest_task_node->mapped_server_node;

  
  if(mg_dest_task_node->mapped_server_node->server->smart==1){
      
    mg_dest_back_link=mg_dest_task_node->mg_node_back_links[dest_back_link_pos];
    mg_for_link->mg_obj_node_ptr=mg_obj_node;
    mg_for_link->mg_node_ptr=mg_dest_node;
   
    
    mg_for_link->mapped_netpm_link=netpm_node->netpm_links[0];
   
    /*
     * Check to see if argument already sent to server
     */
    int i;
    int already_on_server=0;
    gs_server_t * this_dest_server;
    gs_server_t * prev_dest_server;
    gs_smart_mg_task_node * mg_prev_task_node;
    this_dest_server=mg_dest_task_node->mapped_server_node->server;
    for(i=0;(i<mg_this_o_f_link_cnt) && (!already_on_server);i++){
      mg_prev_task_node=mg_obj_node->mg_obj_for_links[i]->mg_node_ptr->mg_task_node;
      prev_dest_server=mg_prev_task_node->mapped_server_node->server;
      if(strcmp(this_dest_server->componentid, prev_dest_server->componentid)==0){
        already_on_server=1; 
        mg_obj_node->mg_obj_for_links[i]->store_arg=1;
      }
    }
                 
    /*
     * if not already on server then send it
     */  
    if(!already_on_server){
      if(netpm_node->netpm_links[0]->bw==0.0){
        netpm_node->netpm_links[0]->bw=netpm->avg_c_bw;
      }
      bw=netpm_node->netpm_links[0]->bw;
      byte_size= mg_for_link->mg_obj_node_ptr->mapped_obj_node->byte_size;
      mg_for_link->time=(double)((byte_size/bw));
      mg_for_link->already_on_server=0;
      mg_obj_node->nb_dest_servers++; 

    }
    else{
      mg_for_link->time=0.0;
      mg_for_link->already_on_server=1;

    }    
 


    mg_obj_node->mg_obj_back_link=(gs_smart_mg_link *)calloc(1, sizeof(gs_smart_mg_link ));

    mg_obj_back_link= mg_obj_node->mg_obj_back_link;
    mg_obj_back_link->mg_node_ptr=mg->mg_nodes[task_id-1];
    mg_obj_back_link->mg_obj_node_ptr=mg_obj_node;

    mg_dest_task_node->mg_node_back_links[dest_back_link_pos]=mg_for_link;
    mg_dest_task_node->back_link_set[dest_back_link_pos]=2;
    mg_this_o_f_link_cnt++;
  }
  * mg_next_o_f_link_cnt= mg_this_o_f_link_cnt; 

       

  return 0;
}






int gs_smart_mg_count_s_comm_for_obj_links(gs_smart_tg * tg, gs_smart_netpm * netpm,
                                    gs_smart_mg *mg, int task_id, 
                                 int for_link_id, int * _mg_nb_obj_for_links, int * _sent_remotely){
  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_mg_node * mg_node;
  gs_smart_mg_task_node * mg_task_node=NULL, * mg_dest_task_node=NULL;
  gs_smart_mg_link  * mg_for_link;
  gs_smart_tg_obj_node * tg_obj_node; 
  gs_smart_tg_task_node * tg_dest_task_node;

  int j,k;
  int tg_nb_obj_for_links, mg_nb_obj_for_links;
  int dest_task_id;
  int sent_remotely=1;

  j=for_link_id;
 
  mg_node=mg->mg_nodes[task_id];
   
  mg_task_node=mg_node->mg_task_node;
  tg_rem_task_node=tg->task_nodes[task_id]->tg_rem_task_node;

  mg_for_link=mg_task_node->mg_node_for_links[j];
  tg_nb_obj_for_links=tg_rem_task_node->tg_node_frwrd_link[j]->obj_node_ptr->nb_obj_frwd_links;
  mg_nb_obj_for_links=tg_nb_obj_for_links;
  if(mg_task_node->mapped_server_node->server->smart==0){
    mg_nb_obj_for_links=1;
    sent_remotely=0;
  }
  else{
    for(k=0; k<tg_nb_obj_for_links;k++){
      tg_obj_node=tg_rem_task_node->tg_node_frwrd_link[j]->obj_node_ptr;
      tg_dest_task_node=tg_obj_node->tg_obj_frwrd_link[k]->task_node_ptr;
      dest_task_id=tg_dest_task_node->id;
      if(mg->mg_nodes[dest_task_id]->node_type==GS_SMART_MG_TASK_NODE){
        mg_dest_task_node=mg->mg_nodes[dest_task_id]->mg_task_node;
        if(mg_dest_task_node->mapped_server_node->server->smart==0){
          *_mg_nb_obj_for_links=1;
          *_sent_remotely=0;
          return 0;
        }
      }
    }
    
  }
  tg_obj_node=tg_rem_task_node->tg_node_frwrd_link[j]->obj_node_ptr;
  tg_dest_task_node=tg_obj_node->tg_obj_frwrd_link[0]->task_node_ptr;
  if((tg_dest_task_node->node_type==GS_SMART_TG_CLIENT_NODE) ||  (mg_nb_obj_for_links==0)){
    sent_remotely=0;
    mg_nb_obj_for_links=1;
  }

  *_mg_nb_obj_for_links=mg_nb_obj_for_links;
  *_sent_remotely=sent_remotely;
  return 0;
}






int gs_smart_mg_construct_s_comm_obj_for_links(gs_smart_tg * tg, gs_smart_netpm * netpm,
                         gs_smart_mg *mg, int task_id, int j, int mg_nb_obj_for_links){

  gs_smart_mg_node * mg_node;
  gs_smart_mg_task_node * mg_task_node=NULL;
  gs_smart_mg_obj_node * mg_obj_node;
  gs_smart_mg_link  * mg_for_link;
  int i;
  mg_node=mg->mg_nodes[task_id];
   
  mg_task_node=mg_node->mg_task_node;
       
  mg_for_link=mg_task_node->mg_node_for_links[j];
  mg_obj_node=mg_for_link-> mg_obj_node_ptr;
  mg_for_link->for_link_pos=j;

  mg_obj_node->nb_for_links=mg_nb_obj_for_links;
  mg_obj_node->mg_obj_for_links=(gs_smart_mg_link **)
                 calloc(mg_nb_obj_for_links, sizeof(gs_smart_mg_link *)); 

  for(i=0;i<mg_nb_obj_for_links;i++){
    mg_obj_node->mg_obj_for_links[i]=(gs_smart_mg_link *)
                   calloc(1, sizeof(gs_smart_mg_link));
  }

  mg_obj_node->mg_obj_for_links[mg_nb_obj_for_links-1]->delete_arg=1;
  return 0;
}








int gs_smart_mg_set_s_comm(gs_smart_tg * tg, gs_smart_netpm * netpm,
                         gs_smart_mg *mg, int task_id, int for_task_link_pos, int k,
                         int mg_this_o_f_link_cnt, int * mg_next_o_f_link_cnt){

  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_tg_task_node * tg_dest_task_node;
  gs_smart_tg_obj_node * tg_obj_node; 
  gs_smart_mg_task_node * mg_task_node=NULL, * mg_dest_task_node=NULL;
  gs_smart_mg_obj_node * mg_obj_node;
  gs_smart_mg_link  * mg_for_link, * mg_obj_for_link=NULL;
  gs_smart_mg_link  * mg_dest_back_link;
  gs_smart_mg_node * mg_node;
  gs_smart_netpm_node * netpm_node;
  gs_server_t * this_dest_server;
  gs_server_t * prev_dest_server;
  gs_smart_mg_task_node * mg_prev_task_node;
  int dest_task_id=0,  tg_nb_obj_for_links;
  int dest_back_link_pos=0; 
  int src_smart_id, dest_smart_id;
  int netpm_for_link_pos;
  int byte_size;
  double bw;
  int already_on_server=0;
  int j;
 
  mg_node=mg->mg_nodes[task_id];
  mg_task_node=mg_node->mg_task_node;

  tg_rem_task_node=tg->task_nodes[task_id]->tg_rem_task_node;
  mg_for_link=mg_task_node->mg_node_for_links[for_task_link_pos];
  mg_obj_node=mg_for_link->mg_obj_node_ptr;
  netpm_node= mg_task_node->mapped_server_node;
  tg_nb_obj_for_links=mg_obj_node->mapped_obj_node->nb_obj_frwd_links; 
 
   if(mg_obj_node->sent_remotely==1){
     tg_obj_node=tg_rem_task_node->tg_node_frwrd_link[for_task_link_pos]->obj_node_ptr;
     tg_dest_task_node=tg_obj_node->tg_obj_frwrd_link[k]->task_node_ptr;
     dest_back_link_pos=tg_obj_node->tg_obj_frwrd_link[k]->back_link_pos;

     dest_task_id=tg_dest_task_node->id;
     if(mg->mg_nodes[dest_task_id]->node_type==GS_SMART_MG_TASK_NODE){
       mg_dest_task_node=mg->mg_nodes[dest_task_id]->mg_task_node;
       if(mg_dest_task_node->mapped_server_node->server->smart==1){
         src_smart_id= mg_task_node->mapped_server_node->server->smart_id;
         dest_smart_id=mg_dest_task_node->mapped_server_node->server->smart_id;
         mg_obj_for_link=mg_obj_node->mg_obj_for_links[ mg_this_o_f_link_cnt];
         mg_obj_for_link->for_link_pos= mg_this_o_f_link_cnt;
         mg_obj_for_link->mg_obj_node_ptr=mg_obj_node;
        
         if(dest_smart_id==src_smart_id){
           netpm_for_link_pos=-1; 
           mg_obj_for_link->caching=1;   
         }
         else if(dest_smart_id>src_smart_id){
           netpm_for_link_pos=dest_smart_id;
           mg_obj_for_link->caching=0;
         }
         else{
           netpm_for_link_pos=dest_smart_id+1;
           mg_obj_for_link->caching=0;
         }
         mg_obj_for_link->mg_node_ptr=mg->mg_nodes[dest_task_id];

         mg_obj_for_link->mg_obj_node_ptr=mg_obj_node;

         already_on_server=0;

         this_dest_server=mg_dest_task_node->mapped_server_node->server;

         for(j=0; (j<mg_this_o_f_link_cnt) && (!already_on_server) ;j++){
           mg_prev_task_node=mg_obj_node->mg_obj_for_links[j]->mg_node_ptr->mg_task_node;
           prev_dest_server=mg_prev_task_node->mapped_server_node->server;
           if(strcmp(this_dest_server->componentid, prev_dest_server->componentid)==0){
             already_on_server=1; 
           }
         }
         if(already_on_server){
          // mg->total_time=0.0;
           mg_obj_for_link->already_on_server=1;
         }
         else{
           if(!mg_obj_for_link->caching){
             mg_obj_for_link->mapped_netpm_link=netpm_node->netpm_links[netpm_for_link_pos];
           
             if(netpm_node->netpm_links[netpm_for_link_pos]->bw==0.0){
               netpm_node->netpm_links[netpm_for_link_pos]->bw=netpm->avg_s_bw;
             }

             bw=netpm_node->netpm_links[netpm_for_link_pos]->bw;
             byte_size=mg_obj_for_link->mg_obj_node_ptr->mapped_obj_node->byte_size;
             mg_obj_for_link->time=(double)((byte_size/bw));
             mg->total_time=mg->total_time+mg_obj_for_link->time;
             mg_obj_node->nb_dest_servers++;
           }
           else if(mg_obj_for_link->caching){
             byte_size=mg_obj_for_link->mg_obj_node_ptr->mapped_obj_node->byte_size;
             mg_obj_for_link->time=(double)((double)(byte_size/(double)100000000));
             mg->total_time=mg->total_time+mg_obj_for_link->time;
           }
           mg_obj_for_link->already_on_server=0;
         }
         mg_dest_back_link= mg_dest_task_node->mg_node_back_links[dest_back_link_pos];
  
         mg_dest_task_node->mg_node_back_links[dest_back_link_pos]=mg_obj_for_link;
         mg_dest_task_node->back_link_set[dest_back_link_pos]=4;

         mg_obj_node->mg_obj_back_link=(gs_smart_mg_link *)
                                         calloc(1, sizeof(gs_smart_mg_link));
         mg_obj_node->mg_obj_back_link->mg_node_ptr=mg_node;
         mg_obj_node->mg_obj_back_link->mg_obj_node_ptr=mg_obj_node;
 
        mg_this_o_f_link_cnt++; 
      }
     }
   }
   else if(mg_obj_node->sent_remotely==0){
         mg_obj_for_link=mg_obj_node->mg_obj_for_links[0];
         mg_obj_for_link->for_link_pos=0;
          /*
          * Point the obj for link to the next client node
          */  
         mg_obj_for_link->mg_node_ptr=mg->mg_nodes[task_id+1];
         /*
          * Point the object node forward link back on itself
          */ 
         mg_obj_for_link->mg_obj_node_ptr=mg_obj_node;
         
        
         /*
          * Find the netpm link which will be assigned to
          * this forward link.
          */ 
         netpm_node= mg_task_node->mapped_server_node;
         mg_obj_for_link->mapped_netpm_link=netpm_node->netpm_links[0];
          
         double bw=netpm_node->netpm_links[0]->bw;
         int byte_size=mg_obj_for_link->mg_obj_node_ptr->mapped_obj_node->byte_size;
         mg_obj_for_link->time=(double)((byte_size/bw));


           mg->total_time=mg->total_time+mg_obj_for_link->time;



         mg_obj_node->mg_obj_back_link=(gs_smart_mg_link *)
                                         calloc(1, sizeof(gs_smart_mg_link));
         mg_obj_node->mg_obj_back_link->mg_node_ptr=mg_node;
         mg_obj_node->mg_obj_back_link->mg_obj_node_ptr=mg_obj_node;
          mg_this_o_f_link_cnt++;
    }
  

  * mg_next_o_f_link_cnt=mg_this_o_f_link_cnt;

  return 0;
}









int gs_smart_free_mg(gs_smart_mg * mg){
  int i, j;
  gs_smart_mg_node * mg_node;
  gs_smart_mg_task_node * mg_task_node=NULL;

  gs_smart_mg_link * mg_task_back_link, * mg_obj_back_link;
  gs_smart_mg_obj_node * mg_obj_node;

  if(!mg) return -1;
 
  for(i=0;i<mg->nb_mg_nodes;i++){
    if(!mg->mg_nodes[i]) return -1;
    mg_node=mg->mg_nodes[i];
    if(mg_node->node_type==GS_SMART_MG_CLIENT_NODE){
      if(mg_node->mg_client_node) free(mg_node->mg_task_node);
    }
    else if(mg_node->node_type==GS_SMART_MG_TASK_NODE){
      if(!mg_node->mg_task_node) return -1;
      mg_task_node=mg_node->mg_task_node;
      for(j=0;j<mg_task_node->nb_back_links;j++){
        if(!mg_task_node->mg_node_back_links[j]) return -1;
        mg_task_back_link=mg_task_node->mg_node_back_links[j];
        /*
         * Only free obj node and obj back link once
         */ 
        if(mg_task_back_link->for_link_pos==0){
          if(!mg_task_back_link->mg_obj_node_ptr) return -1;
          mg_obj_node=mg_task_back_link->mg_obj_node_ptr; 
          if(!mg_obj_node->mg_obj_back_link) return -1;
          mg_obj_back_link=mg_obj_node->mg_obj_back_link;
          if(mg_obj_back_link) free(mg_obj_back_link);
          if(mg_obj_node) free(mg_obj_node); 
        }
        if(mg_task_back_link) free(mg_task_back_link);

      }

      if(mg_task_node->back_link_set) free(mg_task_node->back_link_set);
      if(mg_task_node->mg_node_for_links) free(mg_task_node->mg_node_for_links); 
      if(mg_task_node) free(mg_task_node);
    }
    if(mg_node) free(mg_node); 
  }
  return 0;
}







int gs_smart_mg_create_argument_file_names(gs_smart_mg *mg){
  gs_smart_mg_task_node * mg_task_node=NULL;
  gs_smart_mg_node * mg_node;
  gs_smart_mg_node * mg_dest_node;
  gs_smart_mg_obj_node * mg_obj_node;
  gs_smart_mg_link * mg_task_for_link, * mg_task_back_link;
  gs_smart_mg_link * mg_obj_for_link, * mg_obj_back_link;
  int i, j;
  int dep_id=0;
  int smart_app_num;
  pid_t pid;
  pid=getpid();
  char GS_SMART_ARG_FILE_EXT[FN_LEN];

  if(gs_smart_read_app_no_file("/tmp/gs_app_num", &smart_app_num)<0){
    ERRPRINTF("SMART : Error reading and updating application number file\n");
    return -1;
  }
  for(i=0;i<mg->nb_mg_nodes;i++){
    mg_node=mg->mg_nodes[i];   
    if(mg_node->node_type==GS_SMART_MG_TASK_NODE){
      mg_task_node=mg_node->mg_task_node;
      for(j=0; j<mg_task_node->nb_back_links; j++){
        mg_task_back_link=mg_task_node-> mg_node_back_links[j];
        mg_obj_node= mg_task_back_link->mg_obj_node_ptr;
        mg_obj_back_link=mg_obj_node->mg_obj_back_link;
        if(mg_obj_back_link->mg_node_ptr->node_type==GS_SMART_MG_CLIENT_NODE){
          if((mg_obj_node->nb_for_links>1) && (!mg_obj_node->smart_arg_file)){
            snprintf(GS_SMART_ARG_FILE_EXT, FN_LEN, "/tmp/gs_smart_arg_files/%s.%d", GS_SMART_ARG_FILE_PREFIX, pid);
            
            if(gs_smart_get_obj_file_name(&mg_obj_node->smart_arg_file, GS_SMART_ARG_FILE_EXT,smart_app_num, dep_id)<0){
              ERRPRINTF("SMART : Error getting argument file name\n");
              return -1;
            }
            dep_id++;
          }
        }
 
      }
      for(j=0; j<mg_task_node->nb_for_links; j++){
        mg_task_for_link=mg_task_node-> mg_node_for_links[j];
        mg_obj_node= mg_task_for_link->mg_obj_node_ptr;
        mg_obj_for_link=mg_obj_node->mg_obj_for_links[0];
        mg_dest_node=mg_obj_for_link-> mg_node_ptr;
        if(mg_dest_node->node_type==GS_SMART_MG_TASK_NODE){
          snprintf(GS_SMART_ARG_FILE_EXT, FN_LEN, "/tmp/gs_smart_arg_files/%s.%d", GS_SMART_ARG_FILE_PREFIX, pid);
            
          if(gs_smart_get_obj_file_name(&mg_obj_node->smart_arg_file, GS_SMART_ARG_FILE_EXT,smart_app_num, dep_id)<0){
            ERRPRINTF("SMART : Error getting argument file name\n");
            return -1;
          }
          dep_id++;
        }
      }
    }
  }

  return 0;
}





int gs_smart_check_if_valid_assignment(gs_smart_tg_remote_task_node * tg_rem_task_node,
                                 gs_server_t * mapped_server, int * _valid_assignment){

   gs_server_t * task_server;
   int i,valid_assignment, nb_servers;
   i=valid_assignment=0;
   nb_servers=tg_rem_task_node->nb_servers;
   for(i=0; ((i< nb_servers)&&(!valid_assignment)) ; i++ ){
     task_server=tg_rem_task_node->avail_servers[i];
     
     if(strcmp(mapped_server->componentid, task_server->componentid)==0){
      
       valid_assignment=1; 
     }
   }

  *_valid_assignment=valid_assignment;
  return 0;
}
















int gs_smart_mg_embed_mapping(grpc_function_handle_t * handle, int task_nb){

  gs_problem_t *problem=NULL;
  gs_argument_t *argptr=NULL;
  gs_smart_mg_node * mg_node=NULL, * mg_src_node=NULL;
  gs_smart_mg_task_node * mg_task_node=NULL;
  gs_smart_mg_task_node * mg_dest_task_node=NULL;
  gs_smart_mg_obj_node * mg_obj_node=NULL;
  gs_smart_mg_link * mg_task_for_link=NULL, * mg_task_back_link=NULL;
  gs_smart_mg_link * mg_obj_for_link=NULL;

  int input_cnt, output_cnt;
  int mg_node_id;
  int i, j;
  int dest_server_cnt=0;
  problem=handle->problem_desc;
  mg_node_id=(task_nb*2+2);
  mg_node=best_mg->mg_nodes[mg_node_id];
  mg_task_node=mg_node->mg_task_node;


  /*
   * Setting task to server mapping
   */ 
  gs_server_t * mapped_server;
  mapped_server=mg_task_node->mapped_server_node->server;

  /*
   * If the SmartGridSolve mapped server is not the same as the top
   * server assigned by GridSolve then change the server list so 
   * that the SmartGridSolve server is the top of the list
   */ 
  if(strcmp(mapped_server->componentid, handle->server_list[0]->componentid)!=0){
    gs_server_t * temp=handle->server_list[0];

    for(i=0;i<handle->num_servers;i++){
      if(strcmp(mapped_server->componentid, handle->server_list[i]->componentid)==0){
        handle->server_list[0]=handle->server_list[i];
        handle->server_list[i]=temp;
        for(j=1;j<i;j++){
          temp=handle->server_list[j];
          handle->server_list[j]=handle->server_list[i];
          handle->server_list[i]=temp; 
        }
        break;
      }
    }
  }
  
  problem->has_smart_arg_comm=0;

  input_cnt=output_cnt=0;
  for(argptr= problem->arglist;argptr!=NULL;argptr=argptr->next) {
    if(argptr->objecttype!=GS_SCALAR){
     /*
      * Examine input object nodes
      */ 
      if( ( argptr->inout==GS_INOUT ) || ( argptr->inout==GS_IN ) ) {
        mg_task_back_link=mg_task_node->mg_node_back_links[input_cnt];
        argptr->input_arg_deleted=mg_task_back_link->delete_arg;
        mg_obj_node=mg_task_back_link->mg_obj_node_ptr;

       if(mg_obj_node->sent_remotely){
          mg_src_node=mg_obj_node->mg_obj_back_link->mg_node_ptr;

          if((mg_node_id-1)== (mg_src_node->id)){
            if(mg_src_node->node_type==GS_SMART_MG_CLIENT_NODE){

              argptr->input_nb_dest_servers=mg_obj_node->nb_dest_servers;
              argptr->enc_input_dest_servers=(char **)
                             calloc(mg_obj_node->nb_dest_servers, sizeof(char *));

              dest_server_cnt=0;
              for(i=0;i<mg_obj_node->nb_for_links ;i++){
                mg_obj_for_link=mg_obj_node->mg_obj_for_links[i];
                mg_dest_task_node=mg_obj_for_link->mg_node_ptr->mg_task_node;
                /*
                 * Check if the input is sent to server in the standard way
                 * or is stored on the server for future tasks
                 */
                  argptr->input_nb_dest_servers=0;
                  if(i==0){
                    if( mg_obj_for_link->store_arg){
                      argptr->input_arg_stored=1;
                      problem->has_smart_arg_comm=1;
                    }
                  }
                  else{
                    /*
                     *  If any of the other broadcast for links are sending 
                     *  to servers that aren't the server of this task
                     *  then embed the info of their file locations. 
                     */  
                    if(!mg_obj_for_link->already_on_server){
                      argptr->input_arg_sent_remotely=1;
                      problem->has_smart_arg_comm=1;
                     
                      gs_server_t * dest_server=mg_dest_task_node->mapped_server_node->server;
                      if(gs_encode_server(&argptr->enc_input_dest_servers[dest_server_cnt], 
                                          dest_server) < 0){
                        ERRPRINTF("SMART: Error encoding server string\n");
                        return -1; 
                      }
                      dest_server_cnt++;
                    }    
                  }
                }
              }
            }
            else{
              problem->has_smart_arg_comm=1;
              argptr->input_arg_received_remotely=1;

            }
 
            argptr->input_arg_file=mg_obj_node->smart_arg_file; 
            
          }
          else{
            argptr->input_arg_received_remotely=0;



          }
         
          argptr->input_nb_dest_servers=dest_server_cnt;
          input_cnt++;
        }

        if( ( argptr->inout==GS_INOUT ) || ( argptr->inout==GS_OUT ) ) {
          mg_task_for_link=mg_task_node->mg_node_for_links[output_cnt];
          mg_obj_node=mg_task_for_link->mg_obj_node_ptr;
          if(mg_obj_node->sent_remotely){
            argptr->output_arg_sent_remotely=1;
            problem->has_smart_arg_comm=1;
 
     


            argptr->output_nb_dest_servers=mg_obj_node->nb_dest_servers;
               
            argptr->enc_output_dest_servers=(char **)
                             calloc(mg_obj_node->nb_dest_servers, sizeof(char *));
 
            dest_server_cnt=0;
            for(i=0;i<mg_obj_node->nb_for_links ;i++){
              mg_obj_for_link=mg_obj_node->mg_obj_for_links[i];
              mg_dest_task_node=mg_obj_for_link->mg_node_ptr->mg_task_node;
           
              if(mg_obj_for_link->caching==1){
                argptr->output_cached=1;
                problem->has_smart_arg_comm=1;
             }  
             else if(!mg_obj_for_link->already_on_server){
               gs_server_t * dest_server=mg_dest_task_node->mapped_server_node->server;
               if(gs_encode_server(&argptr->enc_output_dest_servers[dest_server_cnt], 
                                                                  dest_server) < 0){
                 ERRPRINTF("SMART: Error encoding server string\n");
                 return -1; 
               }
               dest_server_cnt++;
             }    
           }
           argptr->output_arg_file=mg_obj_node->smart_arg_file;
         }
         else{
           argptr->output_arg_sent_remotely=0;
         }
          argptr->output_nb_dest_servers=dest_server_cnt;
         output_cnt++;
       }
     }
   }
  return 0;

}





int gs_smart_time_mg_task_node(gs_smart_mg_task_node * mg_task_node, double * time){
 
 double old_effective_speed = -1.0;
 double new_effective_speed = -1.0;
  double computational_score = -1.0;
  if(!mg_task_node) return -1;
  gs_smart_netpm_node * mapped_server_node;
  gs_smart_tg_remote_task_node * mapped_task_node;

  mapped_server_node=mg_task_node->mapped_server_node;
  mapped_task_node= mg_task_node->mapped_task_node;

 new_effective_speed = ((double) mapped_server_node->server->kflops * (double) mapped_server_node->server->ncpu) /
      (((double) (mapped_server_node->server->workload+ mapped_server_node->server->task_workload) / 100.0) + 1.0);
 old_effective_speed = ((double) mapped_server_node->server->kflops * (double) mapped_server_node->server->ncpu) /
      (((double) (mapped_server_node->server->workload) / 100.0) + 1.0);


  computational_score = (double) mapped_task_node->nb_flops / (double) new_effective_speed;

  if(isnan(computational_score)){
    return -1; 
  }
  //printf("THE COMPUTATIONAL SCORE OF EXECUTING A TASK WITH %f FLOPS ON %s WHEN WORKLOAD IS %d AND TASK WORKLOAD IS %d IS %f\n", mapped_task_node->nb_flops, mapped_server_node->server->hostname, mapped_server_node->server->workload, mapped_server_node->server->task_workload, computational_score);


  *time=computational_score;
  return 0;

}





int gs_smart_time_tg_task_node(gs_smart_tg_remote_task_node * tg_rem_task_node, 
                                           gs_server_t * server, double * time){

 double new_effective_speed = -1.0;
  double computational_score = -1.0;
  if((!tg_rem_task_node ) || (!server)) return -1;


 new_effective_speed = ((double) server->kflops * (double) server->ncpu) /
      (((double) (server->workload + server->task_workload) / 100.0) + 1.0);

  computational_score = (double) tg_rem_task_node->nb_flops / (double) new_effective_speed;

  if(isnan(computational_score)){
    return -1;
  }
  computational_score=computational_score;
  //printf("\n\n\nTIMING TASK NODE ON SERVER %s KFLOPS %d NB_CPU %d WORKLOAD %d TASK WORKLOAD %d COMPUTATIONAL SCORE %f\n", server->hostname,  server->kflops, server->ncpu, server->workload, server->task_workload, computational_score);

  *time=computational_score;
  return 0;

}


int gs_smart_time_tg_task_node_with_c_comm(gs_smart_tg_remote_task_node * tg_rem_task_node, 
                                           gs_server_t * server, double * time){

 double new_effective_speed = -1.0;
  double computational_score = -1.0;
//  int i;
  if((!tg_rem_task_node ) || (!server)) return -1;


 new_effective_speed = ((double) server->kflops * (double) server->ncpu) /
      (((double) (server->workload+ server->task_workload) / 100.0) + 1.0);

  computational_score = (double) tg_rem_task_node->nb_flops / (double) new_effective_speed;

  if(isnan(computational_score)){
    return -1;
  }
 // printf("\n\n\nTIMING TASK NODE ON SERVER %s WORKLOAD %d TASK WORKLOAD %d COMPUTATIONAL SCORE %f\n", server->hostname, server->workload, server->task_workload, computational_score);
/*
  for(i=0;i<tg_rem_task_node->nb_node_bkwd_links;i++){
    printf("BYTE SIZE OF LINK %d IS %d\n", i, tg_rem_task_node->tg_node_bkwrd_link[i]->obj_node_ptr->byte_size);
  }
*/ 
  //printf("\n\n\nCOMMUNICATION LOAD=%d\n", tg_rem_task_node->problem->);
  computational_score=computational_score/100;
  *time=computational_score;
  return 0;

}





int gs_smart_mg_print_to_dotgraph(gs_smart_mg * mg, char * filename){


  gs_smart_mg_node * mg_node, *mg_src_node;
  gs_smart_mg_task_node * mg_task_node;
  gs_smart_mg_task_node * mg_dest_task_node;
  gs_smart_mg_link * mg_for_task_link, * mg_back_task_link;
  gs_smart_mg_obj_node * mg_obj_node=NULL;
  gs_smart_mg_link * mg_obj_for_link;
  FILE *fp;
  int i, j, k, node_type;
  int client_comm_exists;

  fp = fopen(filename, "w");
  if(fp<0){
    ERRPRINTF("SMART: Error opening file\n");
    return -1;
  }
  fprintf(fp, "digraph Mapping_Graph {\n");
  for(i=0; i<mg->nb_mg_nodes;i++){
    mg_node=mg->mg_nodes[i];
    node_type=mg_node->node_type;
    if(node_type==GS_SMART_MG_START_NODE){
      fprintf(fp, " start_node_0 [shape=polygon, label=\"start_node_0\",sides=5, peripheries=2, style=\"filled\", fillcolor=\"#FFA500\" fontsize=\"15.0\"];\n");
      
    }
    if(node_type==GS_SMART_MG_END_NODE){
      fprintf(fp, " end_node_%d [shape=polygon, label=\"end_node_%d\\ntotal_time=%f\",sides=5, peripheries=2, style=\"filled\", fillcolor=\"#FFA500\" fontsize=\"15.0\"];\n", i, i, mg->total_time);
       fprintf(fp, " start_node_0 -> client_1 [color=red];\n");
      fprintf(fp, " client_%d -> end_node_%d [color=red];\n", i-1, i);
      break;
    }
    else if(node_type==GS_SMART_MG_CLIENT_NODE){
      fprintf(fp, " client_%d [shape=\"diamond\", style=\"filled\", fillcolor=\"#ADD8E6\" fontsize=\"15.0\"];\n", i);
    }
    else if(node_type==GS_SMART_TG_REM_TASK_NODE){
      mg_task_node=mg_node->mg_task_node;
      if(mg_task_node->mapped_server_node->server->smart==1){
        fprintf(fp, " %s_%d [shape=box,label=\"%s_%d\\n%s_%d\\nblocking=%d\\ntime=%f\",  style=filled,fillcolor=\"red\",fontsize=15.0];\n", mg_task_node->mapped_task_node->problem->name, i, mg_task_node->mapped_task_node->problem->name, i,  mg_task_node->mapped_server_node->server->hostname, mg_task_node->mapped_server_node->server->port, mg_task_node->mapped_task_node->blocking, mg_task_node->time);

      }
      else
      {
        fprintf(fp, " %s_%d [shape=box,label=\"%s_%d\\n%s_%d\\nblocking=%d\\ntime=%f\",  style=filled,fillcolor=\"deepskyblue\",fontsize=15.0];\n", mg_task_node->mapped_task_node->problem->name, i, mg_task_node->mapped_task_node->problem->name, i,  mg_task_node->mapped_server_node->server->hostname, mg_task_node->mapped_server_node->server->port, mg_task_node->mapped_task_node->blocking, mg_task_node->time);
      
      }
    }
  }

  for(i=0; i<mg->nb_mg_nodes;i++){
    mg_node=mg->mg_nodes[i];
    node_type=mg_node->node_type;
    if(node_type==GS_SMART_MG_TASK_NODE){
      mg_task_node=mg_node->mg_task_node;
      client_comm_exists=0;
      for(j=0;j<mg_task_node->nb_for_links;j++){
         mg_for_task_link= mg_task_node->mg_node_for_links[j];
         mg_obj_node=mg_for_task_link->mg_obj_node_ptr;
        fprintf(fp, " out_%s_%s_%d [label=\"%s\\nbytes=%d\" ];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name,   i, mg_obj_node->mapped_obj_node->name, mg_obj_node->mapped_obj_node->byte_size);

        fprintf(fp, "%s_%d -> out_%s_%s_%d;\n", mg_task_node->mapped_task_node->problem->name, i, mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, i);
         for(k=0;k<mg_obj_node->nb_for_links;k++){
           mg_obj_for_link= mg_obj_node->mg_obj_for_links[k];
           if(mg_obj_for_link->mg_node_ptr->node_type==GS_SMART_MG_TASK_NODE){
             mg_dest_task_node=mg_obj_for_link->mg_node_ptr->mg_task_node;
             if(!mg_obj_for_link->caching){
               if(mg_obj_for_link->already_on_server){
                 fprintf(fp, "out_%s_%s_%d -> %s_%d [color=red label=\"time=%f\"];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, i, mg_dest_task_node->mapped_task_node->problem->name, mg_obj_for_link->mg_node_ptr->id,  mg_obj_for_link->time);

               }
               else{
                 fprintf(fp, "out_%s_%s_%d -> %s_%d [label=\"time=%f\"];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, i, mg_dest_task_node->mapped_task_node->problem->name, mg_obj_for_link->mg_node_ptr->id,  mg_obj_for_link->time);

               }
 
             }
             else{

               if(mg_obj_for_link->already_on_server){
                 fprintf(fp, "out_%s_%s_%d -> %s_%d [color=red label=\"time=%f\" style=dotted];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, i, mg_dest_task_node->mapped_task_node->problem->name, mg_obj_for_link->mg_node_ptr->id,  mg_obj_for_link->time);
               }
               else{
                 fprintf(fp, "out_%s_%s_%d -> %s_%d [label=\"time=%f\" style=dotted];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, i, mg_dest_task_node->mapped_task_node->problem->name, mg_obj_for_link->mg_node_ptr->id,  mg_obj_for_link->time);


               }

             }

           }
           else if(mg_obj_for_link->mg_node_ptr->node_type==GS_SMART_MG_CLIENT_NODE){
             mg_dest_task_node=mg_obj_for_link->mg_node_ptr->mg_task_node;
             if(mg_obj_for_link->already_on_server){
               fprintf(fp, "out_%s_%s_%d -> client_%d [color=red label=\"time=%f\"];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, i, mg_obj_for_link->mg_node_ptr->id, mg_obj_for_link->time);
             }  
             else{
               fprintf(fp, "out_%s_%s_%d -> client_%d [label=\"time=%f\"];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, i, mg_obj_for_link->mg_node_ptr->id, mg_obj_for_link->time);

             }


              client_comm_exists=1;

           }
           
         }
 
      }
      if(!client_comm_exists){
         fprintf(fp, "%s_%d -> client_%d [color=red];\n", mg_task_node->mapped_task_node->problem->name, i, i+1);
      }

 
     client_comm_exists=0;
     for(j=0;j<mg_task_node->nb_back_links;j++){
        mg_back_task_link= mg_task_node->mg_node_back_links[j];
        mg_obj_node=mg_back_task_link->mg_obj_node_ptr;
        mg_src_node=mg_obj_node->mg_obj_back_link->mg_node_ptr;
        if(mg_src_node->node_type==GS_SMART_MG_CLIENT_NODE){
          if((i-1)== (mg_src_node->id)){
            fprintf(fp, " in_%s_%s_%d [label=\"%s\\nbytes=%d\" ];\n", mg_obj_node->mapped_obj_node->name,   mg_task_node->mapped_task_node->problem->name, mg_src_node->id  , mg_obj_node->mapped_obj_node->name, mg_obj_node->mapped_obj_node->byte_size);
            fprintf(fp, "client_%d -> in_%s_%s_%d;\n", mg_src_node->id, mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, mg_src_node->id);
            for(k=0;k<mg_obj_node->nb_for_links;k++){
              mg_obj_for_link=mg_obj_node->mg_obj_for_links[k];
              if(mg_obj_for_link->already_on_server){
                fprintf(fp, "in_%s_%s_%d -> %s_%d [color=red label=\"time=%f\"];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, mg_src_node->id , mg_obj_for_link->mg_node_ptr->mg_task_node->mapped_task_node->problem->name, mg_obj_for_link->mg_node_ptr->id,  mg_obj_for_link->time);
              }
              else{
                fprintf(fp, "in_%s_%s_%d -> %s_%d [label=\"time=%f\"];\n", mg_obj_node->mapped_obj_node->name, mg_task_node->mapped_task_node->problem->name, mg_src_node->id , mg_obj_for_link->mg_node_ptr->mg_task_node->mapped_task_node->problem->name, mg_obj_for_link->mg_node_ptr->id,  mg_obj_for_link->time);
              }
              if(mg_obj_for_link->mg_node_ptr->id==i){
                client_comm_exists=1;
              }
            } 
          } 
        }
      }
      
      if(!client_comm_exists){
         fprintf(fp, "client_%d -> %s_%d [color=red];\n", i-1, mg_task_node->mapped_task_node->problem->name, i);
      }



    }
  }
  fprintf(fp, "\n}\n");
  fclose(fp);
  // system("dot -Tjpg map_graph.dot -o /var/www/col/smartgridsolve/smart_graphs/map_graph.jpg");
  return 0;
}





#endif