gs_smart_task_graph.c

Go to the documentation of this file.

#include "config.h"
#ifdef GS_SMART_GRIDSOLVE
#include "gs_smart_task_graph.h"
#include "gs_smart_mapping_graph.h"
#include "gs_smart_app_pm.h"
#include "comm_data.h"
#include "comm_encode.h"

#include "time.h"

#define DEPENDENCY_FOUND 0
#define DEPENDENCY_NOT_FOUND 1
#define DEP_FOUND_ARG_UPDATED 2
#define DEP_FOUND_ARG_NOT_UPDATED 3
#define DEP_NOT_FOUND_ARG_UPDATED 4
#define DEP_NOT_FOUND_ARG_NOT_UPDATED 5
#define ERROR -1






int gs_smart_generate_netpm_and_task_graph( gs_smart_app_pm * app_pm, gs_smart_tg * tg,
                          gs_smart_netpm * netpm, char *comm_type){

  gs_server_t ** server_list;
  int nb_servers;
  char *msg=NULL;
  int agentport, tag;
  char *agent = NULL;    
  SOCKET sock;

 if(!netpm) return -1;
  
  if((agent = getenv("GRIDSOLVE_AGENT")) == NULL){
    ERRPRINTF("SMART: Error getting agent env variable\n");
    return -1;
  }
  agentport = getenv_int("GRIDSOLVE_AGENT_PORT", GRIDSOLVE_AGENT_PORT_DEFAULT);

  if((sock = gs_connect_direct(agent, agentport)) == INVALID_SOCKET){
    ERRPRINTF("SMART: error connecting to agent port\n");
    if(agent) free(agent);
    if(app_pm) gs_smart_app_pm_free(app_pm);
    return -1;
  }

  if((gs_send_tag(sock, GS_PROT_APP_PM_MODEL) < 0) ||
      (gs_send_string(sock, VERSION) < 0) ||
      (gs_recv_tag(sock, &tag) < 0)){
     ERRPRINTF("SMART : Send recv tag error\n");
     return -1;
   }

   if(tag != GS_PROT_OK) {
      if(tag == GS_PROT_VERSION_MISMATCH) {
        ERRPRINTF("SMART: Error version mismatch\n");
        if(app_pm) gs_smart_app_pm_free(app_pm);
        return -1;
      } 
      else {
        ERRPRINTF("SMART: Tag error\n");
        if(app_pm) gs_smart_app_pm_free(app_pm);
        return -1;
      }
    }
    /*
     * Sending the communication scheme to implement
     * in task graph
     */ 
    if(gs_send_string(sock, comm_type) < 0){
      ERRPRINTF("SMART: Error sending application perforance model failed\n");
      if(app_pm) gs_smart_app_pm_free(app_pm);
      return -1;
    }
    
    /*
     * Encoding application performance model
     * to send to the agent
     */ 
    if(gs_smart_encode_app_pm(&msg, app_pm)  < 0) {
      ERRPRINTF("SMART: encode app_pm failed\n");
      if(msg) free(msg);
      if(app_pm) gs_smart_app_pm_free(app_pm);
      return -1;
    }

    /*
     * Sending encoded app pm to agent
     */ 
    if(gs_send_string(sock, msg) < 0){
      ERRPRINTF("SMART: Error sending application perforance model failed\n");
      if(msg) free(msg);
      if(app_pm) gs_smart_app_pm_free(app_pm);
      return -1;
    }
   if(msg) free(msg);
    if(gs_recv_tag(sock, &tag)<0){
      ERRPRINTF("SMART: Error receiving tag\n");
      if(app_pm) gs_smart_app_pm_free(app_pm);
      return -1;
    }
    if(tag==GS_SMART_GRAPH_FAIL){
      ERRPRINTF("SMART: Task graph could not be created, this may be due to no servers being registered\n");
      return -1;
    }
    if(tag==GS_SMART_GRAPH_OK){
      DBGPRINTF("SMART: Task graph created successfully\n");
    }
    else{
      ERRPRINTF("SMART: Invalid tag received from agent\n");
      return -1;
    }
    /*
     * Receiving the task graph from agent
     */ 

    if(gs_smart_recv_tg(sock, tg)<0){
      DBGPRINTF("SMART: Recv task graph failed\n");
      if(tg)  gs_smart_tg_free(tg);
      if(app_pm) gs_smart_app_pm_free(app_pm);
      return -1;
    }

   /* 
    *  Client receives all servers that can execute tasks in task 
    *  graph and their corresponding bandwidth ping info
    */
    
    if(gs_smart_recv_all_servers(sock, &server_list, &nb_servers)){
      int i;
      ERRPRINTF("SMART: Error receive all servers failed\n");
      if(tg)  gs_smart_tg_free(tg);
      if(app_pm) gs_smart_app_pm_free(app_pm);
      for(i=0;i<nb_servers;i++){ 
        if(server_list[i]) gs_server_free(server_list[i]);
      }
      return -1;
    }

   /*
    * Construct network performance model from list of servers
    */ 
   if(gs_smart_netpm_construct_netpm(netpm, server_list, nb_servers)<0){
     ERRPRINTF("SMART : Error constructing network performance model\n");
     return -1;
   }

   if(gs_recv_tag(sock, &tag) < 0) {
      proxy_close(sock);
      if(tg)  gs_smart_tg_free(tg);
      return -1;
    }

  if(tag==GS_PROT_OK){
    DBGPRINTF("SMART: Mapping comleted successfully\n");
    if(sock != INVALID_SOCKET)  proxy_close(sock);
    return 0;
  }
  else{
    ERRPRINTF("SMART: Mapping tag error\n");
    return -1;
  }

  return 0;
}











int 
gs_smart_tg_construct_tg(gs_smart_app_pm * apm,  gs_smart_tg * tg, int graph_type){
 
  gs_smart_graph_indexes * gi;   
  gs_smart_app_pm_task * this_apm_task;


  
  if((!apm) || (!tg)) return -1;

  
  if(gs_smart_init_graph_indexes(&gi)<0){
    ERRPRINTF("Smart : Error initialising graph indexes\n");
    return -1;
  }
 
  if(!gi) return -1;

  if(gs_smart_tg_analyse_dependencies(apm, tg, graph_type)<0){
    ERRPRINTF("Smart : Error analysing dependencies of apm\n");
    return -1;
  }


  /*
   * Initialises array of task nodes
   */
   
  if(gs_smart_tg_construct_frame(apm, tg)<0){
    ERRPRINTF("Smart : Error constructing frame of task graph\n");
    return -1;
  }


  if(!apm->tasks) return -1;

  for(gi->ap_ti=0;gi->ap_ti<apm->nb_tasks;gi->ap_ti++){

    if(!apm->tasks[gi->ap_ti]) return -1;

    this_apm_task=apm->tasks[gi->ap_ti];
    if(gi->ap_ti==0){
      if(gs_smart_tg_construct_start_node(tg, gi)<0){
        ERRPRINTF("Smart : Error constructing start node of task graph\n");
        return -1;
      } 
      gi->tg_ti++;
      if(gs_smart_tg_construct_client_node(apm, tg, gi)<0){
        ERRPRINTF("Smart : Error constructing client node of task graph\n");
        return -1;
      } 
      if(gs_smart_tg_construct_forward_links(apm, tg, gi)<0){
        ERRPRINTF("Smart : Error constructing forward links of task graph\n");
        return -1;
      } 
      gi->tg_ti++;

    }
    else if(gi->ap_ti>0){
      if(gs_smart_tg_construct_client_node(apm, tg, gi)<0){
        ERRPRINTF("Smart : Error constructing client node of task graph\n");
        return -1;
      } 
      if(gs_smart_tg_construct_forward_links(apm, tg, gi)<0){
        ERRPRINTF("Smart : Error constructing forward links of task graph\n");
        return -1;
      } 
      if(gs_smart_tg_construct_backward_links(apm, tg, gi)<0){
        ERRPRINTF("Smart : Error constructing backward links of task graph\n");
        return -1;
      } 
      if(gs_smart_tg_join_for_back_links(apm, tg,gi)<0){
        ERRPRINTF("SMART: Error joining dependencies links\n");
        return -1;
      }
      gi->tg_ti++;
    }

    if(gs_smart_tg_construct_remote_task_node(apm, tg, gi)<0){
      ERRPRINTF("Smart : Error constructing remote task node of task graph\n");  
      return -1;
    }
    if(gs_smart_tg_construct_forward_links(apm,tg, gi)<0){
      ERRPRINTF("Smart : Error constructing forward links of task graph\n");
      return -1;
    }
    if(gs_smart_tg_construct_backward_links(apm, tg, gi)<0){                      
      ERRPRINTF("Smart : Error constructing backward links of task graph\n");
      return -1;
    } 
    if(gs_smart_tg_join_for_back_links(apm, tg,gi)<0){
      ERRPRINTF("SMART: Error joining dependencies links\n");
      return -1;
    }
    gi->tg_ti++;

    if(gi->tg_ti==tg->nb_nodes-2){
     if(gs_smart_tg_construct_client_node(apm, tg, gi)<0){
        ERRPRINTF("Smart : Error constructing client node of task graph\n");
        return -1;
      }

      if(gs_smart_tg_construct_backward_links(apm, tg, gi)<0){
        ERRPRINTF("Smart : Error constructing backward links of task graph\n");
        return -1;
      } 
      if(gs_smart_tg_join_for_back_links(apm, tg,gi)<0){
        ERRPRINTF("SMART: Error joining dependencies links\n");
        return -1;
      }
      gi->tg_ti++;
     
      if(gs_smart_tg_construct_end_node(tg, gi)<0){
        ERRPRINTF("Smart : Error constructing end node\n");
        return -1;
      } 
    }
  }
  return 0;
  
}





/*
 * This function contructs and initialises the structure
 * which keeps track of the current position when traversing
 * both the task graph and application pm graph.
 * 
 * @param gi -- (inout )graph index structure
 */


int gs_smart_init_graph_indexes(gs_smart_graph_indexes ** _gi){
  gs_smart_graph_indexes * gi;
  gi=(gs_smart_graph_indexes *)calloc(1, sizeof(gs_smart_graph_indexes));
  if(!gi){
    ERRPRINTF("Smart : Error allocating graph indexes\n");
    return -1;
  }
  gi->rem_dep_id=0; 
 gi->cur_arg_id=0;
  gi->tg_ti=0;
  gi->tg_sti=0; /* task node index */
  gi->tg_dti=0;
  gi->tg_lnai=0; /* task graph local node arg index */
  gi->tg_rnai=0;
  gi->tg_drnai=0; /* destination task node arg index */

  gi->ap_ti=0;
  gi->ap_sti=0;  /* src handle index */
  gi->ap_dti=0;  /* dest handle index */
  gi->ap_sai=0;  /* src handle arg index */
  gi->ap_dai=0;  /* dest handle arg index */

 
  *_gi=gi; 

  return 0;
}


/*
 *   This function analyzes the dependencies between tasks in the 
 *   application performance model.  It stores the results of this analysis 
 *   in the gs_smart_t_dep_anayl and the gs_smart_a_dep_anayl structures of 
 *   each app_pm nodes.  This information is subsequently used to construct 
 *   the links in the task graph.
 *   
 *   @param apm -- application performance model
 *   @param tg -- task graph 
 *   @param graph_type -- the type of graph to generate 
 *   'GS_SMART_NO_DEP_GRAPH' - Generate a task graph with no dependencies
 *   'GS_SMART_P2P_GRAPH' - Generate a task graph with peer to peer dependencies
 *   'GS_SMART_SRV_BRDCST_GRAPH' - Generate a task graph with server broadcast 
 *   dependencies
 *   'GS_SMART_CL_SRV_BRDCST_GRAPH' - Generate a task graph with both client and
 *   server broadcast dependencies
 *   
 *   @returns 0 on success, -1 on failure.
 */

int 
gs_smart_tg_analyse_dependencies(gs_smart_app_pm * apm,  
     gs_smart_tg * tg, int graph_type){

  if((!apm) || (!tg)) return -1;

  if(graph_type==GS_SMART_NO_DEP_GRAPH){
    if(gs_smart_tg_analyse_no_dependencies(apm, tg)<0){
      ERRPRINTF("Smart : Error analysing p2p dependencies of apm\n");
      return -1;
    }
  }
  else if(graph_type==GS_SMART_P2P_GRAPH){
    if(gs_smart_tg_analyse_p2p_dependencies(apm, tg)<0){
      ERRPRINTF("Smart : Error analysing p2p dependencies of apm\n");
      return -1;
    }
  }
  else if(graph_type==GS_SMART_SRV_BRDCST_GRAPH){
    if(gs_smart_tg_analyse_srvr_brdcst_dependencies(apm, tg)<0){
      ERRPRINTF("Smart : Error analysing brdcst dependencies of apm\n");
      return -1;
    }
  }
  else if(graph_type==GS_SMART_CLNT_BRDCAST_COMM){
    if(gs_smart_tg_analyse_clnt_brdcst_dependencies(apm, tg)<0){
      ERRPRINTF("Smart : Error analysing brdcst dependencies of apm\n");
      return -1;
    }
  }
  else if(graph_type==GS_SMART_CL_SRV_BRDCST_GRAPH){
    if(gs_smart_tg_analyse_clnt_srvr_brdcst_dependencies(apm, tg)<0){
      ERRPRINTF("Smart : Error analysing brdcst dependencies of apm\n");
      return -1;
    }
  }
  else{
    ERRPRINTF("Smart : Error invalid graph type\n");
    return -1;
  }
  return 0;
}

/*
 * This function is called when it is requested that no remote communication
 * should be implemented.
 *
 *
 *   @param apm -- application performance model
 *   @param tg -- task graph 
 *   @returns 0 on success, -1 on failure.
 */



int
gs_smart_tg_analyse_no_dependencies(gs_smart_app_pm * apm,
    gs_smart_tg * task_graph){


  gs_argument_t *argptr=NULL;
  gs_smart_graph_indexes * gi;   
  gs_smart_app_pm_args * src_arg;
  gs_smart_app_pm_task * apm_src_task;
  gs_smart_t_dep_anayl * src_t_anayl;
  gs_smart_a_dep_anayl * src_a_anayl;

  if((!apm) || (!task_graph)) return -1;

  if(gs_smart_init_graph_indexes(&gi)<0){
    ERRPRINTF("Smart : Error initialising graph indexes\n");
    return -1;
  }
 
  if(!apm->tasks) return -1;
  
  for(gi->ap_ti=0;gi->ap_ti<apm->nb_tasks;gi->ap_ti++){   
    if(!apm->tasks[gi->ap_ti]) return -1;
    apm_src_task= apm->tasks[gi->ap_ti];

    if(!apm_src_task->t_anayl) return -1;
    src_t_anayl=apm_src_task->t_anayl;

    gi->ap_ai=0; 

    if(!apm_src_task->problem) return -1;

    if(!apm_src_task->args) return -1;

    for(argptr=apm_src_task->problem->arglist;argptr!=NULL;argptr=argptr->next){
      
      if(argptr->objecttype!=GS_SCALAR){
     
        if(!apm_src_task->args[gi->ap_ai]) return -1;
        src_arg=apm_src_task->args[gi->ap_ai]; 

        if(!src_arg->a_anayl) return -1;
        src_a_anayl=src_arg->a_anayl;

       /*
        * if the arg is an output then add a forward task link to this task node
        * and a backward link to the next client node. 
        */  
        if(( (argptr->inout==GS_OUT) || (argptr->inout==GS_INOUT))){
          src_t_anayl->nb_next_client_back_links++;
          src_t_anayl->nb_task_for_links++;
        }
       
       /*
        * if the arg is an input then add a backward link to this task node
        * and a forward link to the previous client node. 
        */  

         if((argptr->inout==GS_INOUT) || (argptr->inout==GS_IN)){
           src_t_anayl->nb_prev_client_for_links++;
           src_t_anayl->nb_task_back_links++;
        }
      }
      gi->ap_ai++;
    }
 
  }
  return 0;
}






int 
gs_smart_tg_analyse_p2p_dependencies(gs_smart_app_pm * apm,  
    gs_smart_tg * task_graph){

  gs_argument_t *argptr=NULL, *src_argptr=NULL, *dest_argptr=NULL;

  gs_smart_graph_indexes * gi;   
  gs_smart_app_pm_args * src_arg, * dest_arg;
  gs_smart_app_pm_task * apm_src_task, * apm_dest_task;
  gs_smart_t_dep_anayl * src_t_anayl, * dest_t_anayl;
  gs_smart_a_dep_anayl * src_a_anayl, * dest_a_anayl;

  int status, result;
  int ap_dai, ap_dti;
  int tg_bli, tg_dti;
  if((!apm) || (!task_graph)) return -1;

  if(gs_smart_init_graph_indexes(&gi)<0){
    ERRPRINTF("Smart : Error initialising graph indexes\n");
    return -1;
  }
 
  gi->tg_ti=2; 
  
  if(!apm->tasks) return -1;
  
  for(gi->ap_ti=0;gi->ap_ti<apm->nb_tasks;gi->ap_ti++){   
    if(!apm->tasks[gi->ap_ti]) return -1;
    apm_src_task= apm->tasks[gi->ap_ti];

    if(!apm_src_task->t_anayl) return -1;
    src_t_anayl=apm_src_task->t_anayl;

    gi->ap_ai=0; 
    gi->tg_fli=0;

    if(!apm_src_task->problem) return -1;

    if(!apm_src_task->args) return -1;

    for(argptr=apm_src_task->problem->arglist;argptr!=NULL;argptr=argptr->next){
      
      if(argptr->objecttype!=GS_SCALAR){
     
        if(!apm_src_task->args[gi->ap_ai]) return -1;
        src_arg=apm_src_task->args[gi->ap_ai]; 

        if(!src_arg->a_anayl) return -1;
        src_a_anayl=src_arg->a_anayl;

    /*
     * If this argument (argptr/src_argptr) is an output add a forward link to
     * this task node and add a back link to the next client node.
     * Then a dependency search is performed to determine if there is any input
     * arguments (dest_argptr) of subsequent tasks which have a dependency
     * on src_argptr.
     * If there is a dependency and dest_argptr is a either a GS_INOUT or GS_OUT
     * then the dependency is set.
     * If there is a dependency and dest_argptr is GS_IN only and is not the last
     * task (gi->ap_dti==apm->nb_tasks-1), then a subsequent
     * dependency search must be done. This depenency search evaluates whether 
     * any subsequent tasks have a dependency on the 
     * dependent argument (dest_argptr from the previous search). 
     * If this is the case, then a broadcast is required. 
     * Since this is p2p analysis, no dependency will be set as the output argument
     * is required by both tasks.
     * However if no broadcast is found then the dependency is set.
     */
        if(( (argptr->inout==GS_OUT) || (argptr->inout==GS_INOUT))){
          src_t_anayl->nb_next_client_back_links++;
          src_t_anayl->nb_task_for_links++;
          status=DEPENDENCY_NOT_FOUND;
          gi->ap_sti=gi->ap_ti;
          gi->ap_dti=gi->ap_sti+1;
          gi->tg_sti=gi->tg_ti; 
          gi->ap_sai=gi->ap_ai;
          gi->tg_dti= gi->tg_sti+2;
          src_argptr=argptr;
          if(gs_smart_tg_dependency_search(apm,  src_argptr,   
                                                       &dest_argptr, gi, &result)<0){
            ERRPRINTF("SMART: Error performing dependency search\n");
            return -1;
          }

          if(!dest_argptr) return -1;
          ap_dti=gi->ap_dti;
          ap_dai=gi->ap_dai;
          tg_bli=gi->tg_bli;
          tg_dti=gi->tg_dti;
          
          if((result==DEP_FOUND_ARG_UPDATED) || (result==DEP_FOUND_ARG_NOT_UPDATED)){

            if(!apm->tasks[ap_dti]) return -1;
            apm_dest_task=apm->tasks[ap_dti];
         
            if(!apm_dest_task->t_anayl) return -1;
            dest_t_anayl=apm_dest_task->t_anayl;

            if(!apm_dest_task->args) return -1;
            if(!apm_dest_task->args[ap_dai]) return -1;

            dest_arg=apm_dest_task->args[ap_dai];

            if(!dest_arg->a_anayl) return -1;
            dest_a_anayl=dest_arg->a_anayl;

            if(gi->ap_dti==apm->nb_tasks-1){
              if(gs_smart_tg_dep_anayl_set_remote_dep(src_t_anayl, 
                   dest_t_anayl,src_a_anayl, dest_a_anayl,gi, argptr->inout)<0){
                ERRPRINTF("SMART: Error setting dependency anaylsis structures\n");
                return -1;
              }
            }
            else if(dest_argptr->inout==GS_IN){
              gi->ap_sti=gi->ap_dti;
              gi->ap_dti=gi->ap_sti+1;
              gi->ap_sai=gi->ap_dai;

              if(!dest_argptr) return -1;
              src_argptr=dest_argptr;
              int result;
              if(gs_smart_tg_dependency_search(apm, src_argptr,  
                                                     &dest_argptr, gi, &result)<0){
                ERRPRINTF("SMART: Error performing dependency search\n");
                return -1;
              }  
              gi->ap_dti=ap_dti;
              gi->ap_dai=ap_dai;
              gi->tg_bli=tg_bli;
              gi->tg_dti=tg_dti;

              if(result==DEP_NOT_FOUND_ARG_NOT_UPDATED){
                if(gs_smart_tg_dep_anayl_set_remote_dep(src_t_anayl,  dest_t_anayl,
                        src_a_anayl, dest_a_anayl,gi, argptr->inout)<0){
                  ERRPRINTF("SMART: Error setting dependency anaylsis structures\n");
                  return -1;
                }
              }
            }
            else if((dest_argptr->inout==GS_INOUT) || (dest_argptr->inout==GS_OUT)){
              if(gs_smart_tg_dep_anayl_set_remote_dep(src_t_anayl,  dest_t_anayl,
                      src_a_anayl, dest_a_anayl,gi, argptr->inout)<0){
                ERRPRINTF("SMART: Error setting dependency anaylsis structures\n");
                return -1;
              }
            }
          }
          gi->tg_fli++;
        }
       
       /*
        * if the arg is an input then add a backward link to this task node
        * and a forward link to the previous client node. 
        */  
        if((argptr->inout==GS_INOUT) || (argptr->inout==GS_IN)){
           src_t_anayl->nb_prev_client_for_links++;
           src_t_anayl->nb_task_back_links++;
        }
      }
      gi->ap_ai++;
    }
 
    gi->tg_ti=gi->tg_ti+2;
  }
  return 0;
}



int 
gs_smart_tg_analyse_srvr_brdcst_dependencies(gs_smart_app_pm * apm,  
    gs_smart_tg * tg){

  gs_argument_t *argptr=NULL, *src_argptr=NULL, *dest_argptr=NULL;

  gs_smart_graph_indexes * gi=NULL;  //graph indexes 
  gs_smart_app_pm_args * src_arg=NULL, * dest_arg=NULL;
  gs_smart_app_pm_task * apm_src_task=NULL, * apm_dest_task=NULL;
  gs_smart_t_dep_anayl * src_t_anayl=NULL, * dest_t_anayl=NULL;
  gs_smart_a_dep_anayl * src_a_anayl=NULL, * dest_a_anayl=NULL;
  int status;
  int arg_obj_updated=0;
  int result;

  if((!apm) || (!tg)) return -1;
   
  if(gs_smart_init_graph_indexes(&gi)<0){
    ERRPRINTF("Smart : Error initialising graph indexes\n");
    return -1;
  }
 
  gi->tg_ti=2; 
  
  if(!apm->tasks) return -1;
  

  for(gi->ap_ti=0;gi->ap_ti<apm->nb_tasks;gi->ap_ti++){   


    if(!apm->tasks[gi->ap_ti]) return -1;
    apm_src_task= apm->tasks[gi->ap_ti];


    if(!apm_src_task->t_anayl) return -1;
    src_t_anayl=apm_src_task->t_anayl;


    gi->ap_ai=0; 
    gi->tg_fli=0;
    gi->tg_clnt_fli=0;

    if(!apm_src_task->problem) return -1;

    if(!apm_src_task->args) return -1;

    for(argptr=apm_src_task->problem->arglist;argptr!=NULL;argptr=argptr->next){
      if(argptr->objecttype!=GS_SCALAR){

        if(!apm_src_task->args[gi->ap_ai]) return -1;
        src_arg=apm_src_task->args[gi->ap_ai]; 

        if(!src_arg->a_anayl) return -1;
        src_a_anayl=src_arg->a_anayl;

        /*
     * If this argument (argptr/src_argptr) is an output add a forward link to
     * this task node and add a back link to the next client node.
     * Then a dependency search is performed to determine if there are input
     * arguments (dest_argptr) of subsequent tasks which have a dependency
     * on src_argptr.
     * This dependency search is repeated even if a dependency is found to determine
     * if server broadcast is required.
     * The search is finished if the arg is updated (i.e. the arg now has new data) 
     * or all tasks have been checked (gi->ap_dti<(apm->nb_tasks-1)). 
     *
         */  
        if(( (argptr->inout==GS_OUT) || (argptr->inout==GS_INOUT))){

          src_t_anayl->nb_next_client_back_links++;
          src_t_anayl->nb_task_for_links++;

          status=DEPENDENCY_NOT_FOUND;
          gi->ap_sti=gi->ap_ti;
          gi->tg_sti=gi->tg_ti; 
          gi->ap_sai=gi->ap_ai;
          gi->ap_dti=gi->ap_sti+1;
          gi->tg_dti=gi->tg_sti+2;
          src_argptr=argptr;
          arg_obj_updated=0;
          while((!arg_obj_updated) && (gi->ap_dti<(apm->nb_tasks))){
            if( gs_smart_tg_dependency_search(apm,  src_argptr,
                                               &dest_argptr, gi, &result)<0 ){
                 ERRPRINTF("Smart: Error doing dependency search\n");
                 return -1;
            }

            if((result==DEP_FOUND_ARG_NOT_UPDATED) || (result==DEP_FOUND_ARG_UPDATED)){
              if(!apm->tasks[gi->ap_dti]) return -1;
              apm_dest_task=apm->tasks[gi->ap_dti];
         
              if(!apm_dest_task->t_anayl) return -1;
              dest_t_anayl=apm_dest_task->t_anayl;

              if(!apm_dest_task->args) return -1;
              if(!apm_dest_task->args[gi->ap_dai]) return -1;

              dest_arg=apm_dest_task->args[gi->ap_dai];

              if(!dest_arg->a_anayl) return -1;
              dest_a_anayl=dest_arg->a_anayl;
            } 

            /*
             * If a dependency is found and if a dependency has not been set 
             * for this arg from a previous task dependency search 
             * (!dest_arg->a_anayl->is_received_remotely) then set the 
             * dependency.
             */
 
            if(((result==DEP_FOUND_ARG_NOT_UPDATED) || 
                 (result==DEP_FOUND_ARG_UPDATED) ) && 
                 (!dest_arg->a_anayl->is_received_remotely)){
              
               if(gs_smart_tg_dep_anayl_set_remote_dep(src_t_anayl,  dest_t_anayl,
                                   src_a_anayl, dest_a_anayl,gi, argptr->inout)<0){
                ERRPRINTF("SMART: Error setting dependency anaylsis structures\n");
                return -1;
              }
              if(result==DEP_FOUND_ARG_UPDATED){
                arg_obj_updated=1;
              }
            }
              
            gi->ap_dti++;
            gi->tg_dti=gi->tg_dti+2; 
            if(gi->ap_dti==(apm->nb_tasks-1)) break;
            if(result==DEP_NOT_FOUND_ARG_UPDATED){
              arg_obj_updated=1;
            }
          }
          gi->tg_fli++;
        }

        
        if(((argptr->inout==GS_IN) || (argptr->inout==GS_INOUT)) 
            && (!src_arg->a_anayl->is_received_remotely)){
          gi->tg_clnt_fli++;
        }

       /*
        * if the arg is an input then add a backward link to this task node
        * and a forward link to the previous client node. 
        */  

         if((argptr->inout==GS_INOUT) || (argptr->inout==GS_IN)){
           src_t_anayl->nb_prev_client_for_links++;
           src_t_anayl->nb_task_back_links++;
        }
      }
      gi->ap_ai++;
    }
 
    gi->tg_ti=gi->tg_ti+2;
  }
  return 0;
}







int 
gs_smart_tg_analyse_clnt_brdcst_dependencies(gs_smart_app_pm * apm,  
    gs_smart_tg * tg){
  gs_argument_t *argptr=NULL, *src_argptr=NULL, *dest_argptr=NULL;

  gs_smart_graph_indexes * gi=NULL;  
  gs_smart_app_pm_args * src_arg=NULL, * dest_arg=NULL;
  gs_smart_app_pm_task * apm_src_task=NULL, * apm_dest_task=NULL;
  gs_smart_t_dep_anayl * src_t_anayl=NULL, * dest_t_anayl=NULL;
  gs_smart_a_dep_anayl * src_a_anayl=NULL, * dest_a_anayl=NULL;
  int status;
  int arg_obj_updated=0;
  int result;

  if((!apm) || (!tg)) return -1;
   
  if(gs_smart_init_graph_indexes(&gi)<0){
    ERRPRINTF("Smart : Error initialising graph indexes\n");
    return -1;
  }
 
  gi->tg_ti=2; 
  
  if(!apm->tasks) return -1;
  

  for(gi->ap_ti=0;gi->ap_ti<apm->nb_tasks;gi->ap_ti++){   


    if(!apm->tasks[gi->ap_ti]) return -1;
    apm_src_task= apm->tasks[gi->ap_ti];


    if(!apm_src_task->t_anayl) return -1;
    src_t_anayl=apm_src_task->t_anayl;


    gi->ap_ai=0; 
    gi->tg_fli=0;
    gi->tg_clnt_fli=0;

    if(!apm_src_task->problem) return -1;

    if(!apm_src_task->args) return -1;

    for(argptr=apm_src_task->problem->arglist;argptr!=NULL;argptr=argptr->next){
      if(argptr->objecttype!=GS_SCALAR){

        if(!apm_src_task->args[gi->ap_ai]) return -1;
        src_arg=apm_src_task->args[gi->ap_ai]; 

        if(!src_arg->a_anayl) return -1;
        src_a_anayl=src_arg->a_anayl;


        /*
     * If this argument (argptr/src_argptr) is an input only, then dependency search 
     * is performed to determine if there are any oppurtunities to client broadcast.
     * This dependency search is repeated even if a dependency found until either 
     * the arg is updated (i.e. the arg now has new data) or all tasks have been checked 
     * (gi->ap_dti<(apm->nb_tasks-1)). 
     *
         */  
        if((argptr->inout==GS_IN) && (!src_arg->a_anayl->is_received_remotely)){
          status=DEPENDENCY_NOT_FOUND;
          gi->ap_sti=gi->ap_ti;
          gi->tg_sti=gi->tg_ti; 
          gi->ap_sai=gi->ap_ai;
          gi->ap_dti=gi->ap_sti+1;
          gi->tg_dti=gi->tg_sti+2;
          src_argptr=argptr;
          arg_obj_updated=0;
          int fin_search=0;
          while((!arg_obj_updated) && (gi->ap_dti<(apm->nb_tasks-1))){
             if( gs_smart_tg_dependency_search(apm,  src_argptr,   
                                               &dest_argptr, gi, &result)<0 ){
               ERRPRINTF("Smart: Error doing dependency search\n");
               return -1;
             }

             if((result==DEP_FOUND_ARG_UPDATED) || (result==DEP_FOUND_ARG_NOT_UPDATED)){ 
              if(!apm->tasks[gi->ap_dti]) return -1;
              apm_dest_task=apm->tasks[gi->ap_dti];
         
              if(!apm_dest_task->t_anayl) return -1;
              dest_t_anayl=apm_dest_task->t_anayl;

              if(!apm_dest_task->args) return -1;
              if(!apm_dest_task->args[gi->ap_dai]) return -1;

              dest_arg=apm_dest_task->args[gi->ap_dai];
            }
  
            if(((result==DEP_FOUND_ARG_UPDATED) || 
                (result==DEP_FOUND_ARG_NOT_UPDATED)) 
                && (!dest_arg->a_anayl->is_received_remotely)){

              if(!dest_arg->a_anayl) return -1;
              dest_a_anayl=dest_arg->a_anayl;

              if(gs_smart_tg_dep_anayl_set_remote_dep(src_t_anayl,  dest_t_anayl,
                        src_a_anayl, dest_a_anayl,gi, argptr->inout)<0){
                ERRPRINTF("SMART: Error setting dependency anaylsis structures\n");
                return -1;
              }
              if(result==DEP_FOUND_ARG_UPDATED){
                arg_obj_updated=1;

              }
              gi->ap_dti++;
              gi->tg_dti=gi->tg_dti+2; 
              if(gi->ap_dti>(apm->nb_tasks-1)){
                fin_search=1;
              } 
            }
           
            if(result==DEP_NOT_FOUND_ARG_UPDATED){
              arg_obj_updated=1;
            }
          }
        }

        if(( (argptr->inout==GS_OUT) || (argptr->inout==GS_INOUT))){

          src_t_anayl->nb_next_client_back_links++;
          src_t_anayl->nb_task_for_links++;
        }
        if(((argptr->inout==GS_IN) || (argptr->inout==GS_INOUT)) 
            && (!src_arg->a_anayl->is_received_remotely)){
          gi->tg_clnt_fli++;
        }

       /*
        * if the arg is an input then add a backward link to this task node
        * and a forward link to the previous client node. 
        */  

         if((argptr->inout==GS_INOUT) || (argptr->inout==GS_IN)){
           src_t_anayl->nb_prev_client_for_links++;
           src_t_anayl->nb_task_back_links++;
        }
      }
      gi->ap_ai++;
    }
 
    gi->tg_ti=gi->tg_ti+2;
  }
  return 0;
}













int 
gs_smart_tg_analyse_clnt_srvr_brdcst_dependencies(gs_smart_app_pm * apm,  
    gs_smart_tg * tg){
  gs_argument_t *argptr=NULL, *src_argptr=NULL, *dest_argptr=NULL;

  gs_smart_graph_indexes * gi=NULL;  
  gs_smart_app_pm_args * src_arg=NULL, * dest_arg=NULL;
  gs_smart_app_pm_task * apm_src_task=NULL, * apm_dest_task=NULL;
  gs_smart_t_dep_anayl * src_t_anayl=NULL, * dest_t_anayl=NULL;
  gs_smart_a_dep_anayl * src_a_anayl=NULL, * dest_a_anayl=NULL;
  int status;
  int arg_obj_updated=0;
  int result;

  if((!apm) || (!tg)) return -1;
   
  if(gs_smart_init_graph_indexes(&gi)<0){
    ERRPRINTF("Smart : Error initialising graph indexes\n");
    return -1;
  }
 
  gi->tg_ti=2; 
  
  if(!apm->tasks) return -1;
  

  for(gi->ap_ti=0;gi->ap_ti<apm->nb_tasks;gi->ap_ti++){   


    if(!apm->tasks[gi->ap_ti]) return -1;
    apm_src_task= apm->tasks[gi->ap_ti];


    if(!apm_src_task->t_anayl) return -1;
    src_t_anayl=apm_src_task->t_anayl;


    gi->ap_ai=0; 
    gi->tg_fli=0;
    gi->tg_clnt_fli=0;

    if(!apm_src_task->problem) return -1;

    if(!apm_src_task->args) return -1;

    for(argptr=apm_src_task->problem->arglist;argptr!=NULL;argptr=argptr->next){
      if(argptr->objecttype!=GS_SCALAR){

        if(!apm_src_task->args[gi->ap_ai]) return -1;
        src_arg=apm_src_task->args[gi->ap_ai]; 

        if(!src_arg->a_anayl) return -1;
        src_a_anayl=src_arg->a_anayl;


        /*
     * If this argument (argptr/src_argptr) is an input only, then dependency search 
     * is performed to determine if there are any oppurtunities to client broadcast.
     * This dependency search is repeated even if a dependency found until either 
     * the arg is updated (i.e. the arg now has new data) or all tasks have been checked 
     * (gi->ap_dti<(apm->nb_tasks-1)). 
     *
         */  
        if((argptr->inout==GS_IN) && (!src_arg->a_anayl->is_received_remotely)){
          status=DEPENDENCY_NOT_FOUND;
          gi->ap_sti=gi->ap_ti;
          gi->tg_sti=gi->tg_ti; 
          gi->ap_sai=gi->ap_ai;
          gi->ap_dti=gi->ap_sti+1;
          gi->tg_dti=gi->tg_sti+2;
          src_argptr=argptr;
          arg_obj_updated=0;
          int fin_search=0;
          while((!arg_obj_updated) && (gi->ap_dti<(apm->nb_tasks))){
             if( gs_smart_tg_dependency_search(apm,  src_argptr,   
                                               &dest_argptr, gi, &result)<0 ){
               ERRPRINTF("Smart: Error doing dependency search\n");
               return -1;
             }

             if((result==DEP_FOUND_ARG_UPDATED) || (result==DEP_FOUND_ARG_NOT_UPDATED)){ 
              if(!apm->tasks[gi->ap_dti]) return -1;
              apm_dest_task=apm->tasks[gi->ap_dti];
         
              if(!apm_dest_task->t_anayl) return -1;
              dest_t_anayl=apm_dest_task->t_anayl;

              if(!apm_dest_task->args) return -1;
              if(!apm_dest_task->args[gi->ap_dai]) return -1;

              dest_arg=apm_dest_task->args[gi->ap_dai];
            }
  
            if(((result==DEP_FOUND_ARG_UPDATED) || 
                (result==DEP_FOUND_ARG_NOT_UPDATED)) 
                && (!dest_arg->a_anayl->is_received_remotely)){

              if(!dest_arg->a_anayl) return -1;
              dest_a_anayl=dest_arg->a_anayl;

              if(gs_smart_tg_dep_anayl_set_remote_dep(src_t_anayl,  dest_t_anayl,
                        src_a_anayl, dest_a_anayl,gi, argptr->inout)<0){
                ERRPRINTF("SMART: Error setting dependency anaylsis structures\n");
                return -1;
              }
              if(result==DEP_FOUND_ARG_UPDATED){
                arg_obj_updated=1;

              }
              gi->ap_dti++;
              gi->tg_dti=gi->tg_dti+2; 
              if(gi->ap_dti>(apm->nb_tasks-1)){
                fin_search=1;
              } 
            }
           
            if(result==DEP_NOT_FOUND_ARG_UPDATED){
              arg_obj_updated=1;
            }
          }
        }

        /*
     * If this argument (argptr/src_argptr) is an output add a forward link to
     * this task node and add a back link to the next client node.
     * Then a dependency search is performed to determine if there are input
     * arguments (dest_argptr) of subsequent tasks which have a dependency
     * on src_argptr.
     * This dependency search is repeated even if a dependency is found to determine
     * if server broadcast is required.
     * The search is finished if the arg is updated (i.e. the arg now has new data) 
     * or all tasks have been checked (gi->ap_dti<(apm->nb_tasks-1)). 
     *
         */  
        
        if(( (argptr->inout==GS_OUT) || (argptr->inout==GS_INOUT))){

          src_t_anayl->nb_next_client_back_links++;
          src_t_anayl->nb_task_for_links++;


          status=DEPENDENCY_NOT_FOUND;
          gi->ap_sti=gi->ap_ti;
          gi->tg_sti=gi->tg_ti; 
          gi->ap_sai=gi->ap_ai;
          gi->ap_dti=gi->ap_sti+1;
          gi->tg_dti=gi->tg_sti+2;
          src_argptr=argptr;
          arg_obj_updated=0;
          while((!arg_obj_updated) && (gi->ap_dti<(apm->nb_tasks))){
            if( gs_smart_tg_dependency_search(apm,  src_argptr,
                                               &dest_argptr, gi, &result)<0 ){
                 ERRPRINTF("Smart: Error doing dependency search\n");
                 return -1;
            }

            if((result==DEP_FOUND_ARG_NOT_UPDATED) || (result==DEP_FOUND_ARG_UPDATED)){
              if(!apm->tasks[gi->ap_dti]) return -1;
              apm_dest_task=apm->tasks[gi->ap_dti];
         
              if(!apm_dest_task->t_anayl) return -1;
              dest_t_anayl=apm_dest_task->t_anayl;

              if(!apm_dest_task->args) return -1;
              if(!apm_dest_task->args[gi->ap_dai]) return -1;

              dest_arg=apm_dest_task->args[gi->ap_dai];

              if(!dest_arg->a_anayl) return -1;
              dest_a_anayl=dest_arg->a_anayl;
            } 
 
            /*
             * If a dependency is found and if a dependency has not been set 
             * for this arg from a previous task dependency search 
             * (!dest_arg->a_anayl->is_received_remotely) then set the 
             * dependency.
             */

            if(((result==DEP_FOUND_ARG_NOT_UPDATED) || 
                 (result==DEP_FOUND_ARG_UPDATED) ) && 
                 (!dest_arg->a_anayl->is_received_remotely)){
              
               if(gs_smart_tg_dep_anayl_set_remote_dep(src_t_anayl,  dest_t_anayl,
                                   src_a_anayl, dest_a_anayl,gi, argptr->inout)<0){
                ERRPRINTF("SMART: Error setting dependency anaylsis structures\n");
                return -1;
              }
              if(result==DEP_FOUND_ARG_UPDATED){
                arg_obj_updated=1;
              }
            }
              
            gi->ap_dti++;
            gi->tg_dti=gi->tg_dti+2; 
            if(gi->ap_dti==(apm->nb_tasks-1)) break;
            if(result==DEP_NOT_FOUND_ARG_UPDATED){
              arg_obj_updated=1;
            }
          }
          gi->tg_fli++;
        }

        if(((argptr->inout==GS_IN) || (argptr->inout==GS_INOUT)) 
            && (!src_arg->a_anayl->is_received_remotely)){
          gi->tg_clnt_fli++;
        }

       /*
        * if the arg is an input then add a backward link to this task node
        * and a forward link to the previous client node. 
        */  

         if((argptr->inout==GS_INOUT) || (argptr->inout==GS_IN)){
           src_t_anayl->nb_prev_client_for_links++;
           src_t_anayl->nb_task_back_links++;
        }
      }
      gi->ap_ai++;
    }
 
    gi->tg_ti=gi->tg_ti+2;
  }
  return 0;
}










int 
gs_smart_tg_construct_frame(gs_smart_app_pm * apm,  
    gs_smart_tg * task_graph){
  

  gs_smart_tg_task_node ** task_nodes;

  if((!apm) || (!task_graph)) return -1;
  int nb_tg_nodes, i;
  nb_tg_nodes=0;   
  nb_tg_nodes=apm->nb_tasks*2+3;
  task_graph->nb_nodes=nb_tg_nodes; 
  task_graph->nb_rem_nodes=apm->nb_tasks;
  task_graph->task_nodes = (gs_smart_tg_task_node **)
                            calloc(nb_tg_nodes, sizeof(gs_smart_tg_task_node *));
 
  if(!task_graph->task_nodes) return -1;
  task_nodes=task_graph->task_nodes;
  
  for(i=0; i<task_graph->nb_nodes;i++){
    task_nodes[i]= (gs_smart_tg_task_node *)
                    calloc(1, sizeof(gs_smart_tg_task_node ));

    if(!task_nodes[i]) return -1;
    task_nodes[i]->id=i;
  }
  return 0;
}



int 
gs_smart_tg_construct_start_node(gs_smart_tg * task_graph, 
    gs_smart_graph_indexes * gi){
  gs_smart_tg_task_node * tg_task_node; 

  if((!task_graph) || (!gi)) return -1;
 
  if(!task_graph->task_nodes) return -1;
  if(!task_graph->task_nodes[0]) return -1; 
  tg_task_node=task_graph->task_nodes[0];

  tg_task_node->node_type= GS_SMART_TG_START_NODE;

  return 0;
}


int 
gs_smart_tg_construct_client_node(gs_smart_app_pm * app_pm,  
    gs_smart_tg * task_graph, gs_smart_graph_indexes * gi){
  
  gs_smart_tg_task_node * tg_task_node; 

  if((!task_graph) || (!gi)) return -1;

  if(!task_graph->task_nodes) return -1;
  if(!task_graph->task_nodes[gi->tg_ti]) return -1;

  tg_task_node=task_graph->task_nodes[gi->tg_ti];
 
  tg_task_node->node_type=GS_SMART_TG_CLIENT_NODE;
 
  tg_task_node->tg_client_node=(gs_smart_tg_client_node *)
                                calloc(1, sizeof(gs_smart_tg_client_node));
  if(!tg_task_node->tg_client_node){
    ERRPRINTF("SMART: Error allocating to local task node\n");
    return -1;
  }

  return 0;
}

int 
gs_smart_tg_construct_remote_task_node(gs_smart_app_pm * apm, 
    gs_smart_tg * task_graph, gs_smart_graph_indexes * gi){

  gs_smart_tg_task_node * tg_task_node; 
  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_app_pm_task * apm_task;
  double nb_flops;

  if( (!apm) || (!task_graph) || (!gi)) return -1;
  
  if((!task_graph->task_nodes) || (!apm->tasks)) return -1;
  if((!task_graph->task_nodes[gi->tg_ti]) || (!apm->tasks[gi->ap_ti])) return -1;
  

  tg_task_node=task_graph->task_nodes[gi->tg_ti];
  apm_task=apm->tasks[gi->ap_ti];

  tg_task_node->node_type=GS_SMART_TG_REM_TASK_NODE;
  

  tg_task_node->tg_rem_task_node=(gs_smart_tg_remote_task_node *)
                                  calloc(1, sizeof(gs_smart_tg_remote_task_node));

  if(!tg_task_node->tg_rem_task_node){
    ERRPRINTF("SMART: Error allocating to local task node\n");
    return -1;
  }
  
  tg_rem_task_node=tg_task_node->tg_rem_task_node;

  if(!apm_task->problem) return -1;

  tg_rem_task_node->problem=apm_task->problem; 

  icl_hash_t *symtab;
  symtab = icl_hash_create(11, NULL);

  if(!symtab) return -1;

  /*
   * Setting up scalar arg values in task handle list (task_list)
   */
  if(gs_smart_tg_set_scalar_arg_values(apm,  symtab, gi)<0){
    ERRPRINTF("Smart: Error gs_smart_set_non_scalar_arg_values\n");
    return -1;
  }

  /*
   * Setting up non-scalar args in task handle list (task_list)
   */ 

  if(gs_setup_workspace(tg_rem_task_node->problem, symtab) < 0) {
    ERRPRINTF("Smart : Error setting up workspace.\n");
    return -1;
  }
 
  if(gs_smart_tg_get_problem_size(tg_rem_task_node->problem, &nb_flops)<0){
    ERRPRINTF("Smart : Error getting problem size\n");
    return -1;
  }
   
  if(nb_flops<0){
    ERRPRINTF("SMART: Error getting nb flops\n");
    return -1;
  }

  tg_rem_task_node->nb_flops=nb_flops;
  tg_rem_task_node->blocking=apm_task->blocking;

  return 0;
}




int
gs_smart_tg_construct_forward_links(gs_smart_app_pm * app_pm, 
  gs_smart_tg * task_graph, gs_smart_graph_indexes * gi){
  
  gs_smart_tg_task_node * tg_task_node; 
  gs_smart_app_pm_task * apm_this_node, * apm_next_node; 
  gs_smart_tg_remote_task_node * tg_rem_task_node=NULL;
  gs_smart_tg_client_node * tg_client_node=NULL;
  int  nb_forward_links , nb_obj_for_links , i;
  gs_smart_tg_dep_link ** forward_links;
  gs_smart_tg_obj_node ** obj_nodes=NULL;
  gs_argument_t *argptr; 
  gs_smart_app_pm_args * this_arg;

  if((!app_pm) || (!task_graph) || (!gi)) return -1;
  
  if((!task_graph->task_nodes) || (!app_pm->tasks)) return -1;
  if((!task_graph->task_nodes[gi->tg_ti]) || (!app_pm->tasks[gi->ap_ti])) return -1;

  tg_task_node=task_graph->task_nodes[gi->tg_ti];
  apm_this_node= app_pm->tasks[gi->ap_ti];  

  if(tg_task_node->node_type==GS_SMART_TG_REM_TASK_NODE){
     
    if((!apm_this_node->t_anayl) || (!tg_task_node->tg_rem_task_node)) return -1;
 
    nb_forward_links=apm_this_node->t_anayl->nb_task_for_links;  
    tg_rem_task_node=tg_task_node->tg_rem_task_node;
    tg_rem_task_node->nb_node_frwd_links=nb_forward_links;  
    tg_rem_task_node->tg_node_frwrd_link=(gs_smart_tg_dep_link **)
         calloc(nb_forward_links, sizeof(gs_smart_tg_dep_link *));
    
    if(!tg_rem_task_node->tg_node_frwrd_link) return -1;

    obj_nodes=(gs_smart_tg_obj_node **)
               calloc(nb_forward_links, sizeof (gs_smart_tg_obj_node *));

    if(!obj_nodes) return -1;

    forward_links=tg_rem_task_node->tg_node_frwrd_link;

    /*
     * Alloc'ing for links and obj nodes for remote task node
     */ 

    gi->tg_fli=0;
    gi->ap_ai=0;
    for(argptr=apm_this_node->problem->arglist;argptr!=NULL;argptr=argptr->next){
      if(!apm_this_node->args[gi->ap_ai]) return -1;
      this_arg=apm_this_node->args[gi->ap_ai];
   
      if( ((argptr->inout==GS_OUT) || (argptr->inout==GS_INOUT)) &&  
                             (argptr->objecttype!=GS_SCALAR)){
      
        forward_links[gi->tg_fli] = (gs_smart_tg_dep_link *)
                            calloc(1, sizeof(gs_smart_tg_dep_link));


        forward_links[gi->tg_fli]->for_link_pos=gi->tg_fli;

         obj_nodes[gi->tg_fli] = (gs_smart_tg_obj_node *)
                        calloc(1, sizeof(gs_smart_tg_obj_node));

        if((!forward_links[gi->tg_fli]) || (!obj_nodes[gi->tg_fli])){
          return -1;
        }

        /*
         * Point remote task two-way forward link to empty object node 
         * and back to itself
         */
        forward_links[gi->tg_fli]->task_node_ptr=tg_task_node;
        forward_links[gi->tg_fli]->obj_node_ptr=obj_nodes[gi->tg_fli];

        forward_links[gi->tg_fli]->obj_node_ptr->out_call_seq_pos=gi->ap_ai;      
        forward_links[gi->tg_fli]->obj_node_ptr->data_ptr=this_arg->id;

        /*
         * Object node back link is the reverse of remote task node forward link.
         * Therefore the pointers of both links are the same.
         */
        obj_nodes[gi->tg_fli]->tg_obj_bkwrd_link=forward_links[gi->tg_fli];


       if(!this_arg->a_anayl) return -1;       
       /*
        * Allocating obj_node forward links
        */
        nb_obj_for_links=this_arg->a_anayl->nb_obj_for_links;
        if(nb_obj_for_links==0){
          nb_obj_for_links++; 
        }
        obj_nodes[gi->tg_fli]->nb_obj_frwd_links=nb_obj_for_links;
        obj_nodes[gi->tg_fli]->tg_obj_frwrd_link=( gs_smart_tg_dep_link **)
                                          calloc(nb_obj_for_links, sizeof(gs_smart_tg_dep_link *));



        if(!obj_nodes[gi->tg_fli]->tg_obj_frwrd_link) return -1;

        for(i=0; i<nb_obj_for_links;i++){  
          obj_nodes[gi->tg_fli]->tg_obj_frwrd_link[i]=(gs_smart_tg_dep_link *)
                                          calloc(1, sizeof(gs_smart_tg_dep_link));
         
          if(!obj_nodes[gi->tg_fli]->tg_obj_frwrd_link[i]) return -1;
          obj_nodes[gi->tg_fli]->tg_obj_frwrd_link[i]->for_link_pos=i;
        }
      
       // i++;
        gi->tg_fli++;
      }
      gi->ap_ai++;
      
    }
  }



    gi->tg_fli=0;
    gi->ap_ai=0;

  if(tg_task_node->node_type==GS_SMART_TG_CLIENT_NODE){
    if(!app_pm->tasks[gi->ap_ti]) return -1;
    apm_next_node= app_pm->tasks[gi->ap_ti]; 
    if(!apm_this_node->t_anayl) return -1; 
    nb_forward_links=apm_this_node->t_anayl->nb_prev_client_for_links;

    if(!tg_task_node->tg_client_node) return -1;
    tg_client_node=tg_task_node->tg_client_node;
    
    tg_client_node->nb_node_frwd_links=nb_forward_links;   


    tg_client_node->tg_node_frwrd_link=(gs_smart_tg_dep_link **)
         calloc(nb_forward_links, sizeof(gs_smart_tg_dep_link *));

    obj_nodes=(gs_smart_tg_obj_node **)
               calloc(nb_forward_links, sizeof (gs_smart_tg_obj_node *));


    if((!tg_client_node->tg_node_frwrd_link) && (!obj_nodes)){
      ERRPRINTF("SMART: Error allocating to object nodes\n");
      return -1;
    }
      
    forward_links=tg_client_node->tg_node_frwrd_link;

    /*
     * Alloc'ing for links and obj nodes for client node
     */ 

    nb_forward_links=0;
    gi->ap_ai=0;
    gi->tg_fli=0; 
    for(argptr=apm_this_node->problem->arglist;argptr!=NULL;argptr=argptr->next){
      this_arg=apm_this_node->args[gi->ap_ai];
      if( ((argptr->inout==GS_IN) || (argptr->inout==GS_INOUT)) &&  
                             (argptr->objecttype!=GS_SCALAR) && 
                             (!this_arg->a_anayl->is_received_remotely)){

      forward_links[gi->tg_fli] = (gs_smart_tg_dep_link *)calloc(1, sizeof(gs_smart_tg_dep_link));
      obj_nodes[gi->tg_fli] = (gs_smart_tg_obj_node *)calloc(1, sizeof(gs_smart_tg_obj_node));
      if((!forward_links[gi->tg_fli]) || (!obj_nodes[gi->tg_fli])){
        return -1;
      }
 
      forward_links[gi->tg_fli]->for_link_pos=gi->tg_fli;

      /*
       * Point client node forward link to empty object node and back to itself
       */
      forward_links[gi->tg_fli]->task_node_ptr=tg_task_node;
      forward_links[gi->tg_fli]->obj_node_ptr=obj_nodes[gi->tg_fli];
      forward_links[gi->tg_fli]->obj_node_ptr->data_ptr=this_arg->id;
      
      /*
       * Object node back link is the reverse of client node forward link.
       * Therefore the pointers of both links are the same.
       */
      obj_nodes[gi->tg_fli]->tg_obj_bkwrd_link=forward_links[gi->tg_fli];


     /*
      * Allocating obj_node forward links
      */
         
      nb_obj_for_links=this_arg->a_anayl->nb_clnt_obj_for_links;     
    

      if(nb_obj_for_links==0){
        nb_obj_for_links++; 
      }

      obj_nodes[gi->tg_fli]->nb_obj_frwd_links=nb_obj_for_links;
      obj_nodes[gi->tg_fli]->tg_obj_frwrd_link=( gs_smart_tg_dep_link **)
                                        calloc(nb_obj_for_links, sizeof(gs_smart_tg_dep_link *));

      if(!obj_nodes[gi->tg_fli]->tg_obj_frwrd_link) return -1;
         
      
      for(i=0; i<nb_obj_for_links;i++){
        obj_nodes[gi->tg_fli]->tg_obj_frwrd_link[i]=(gs_smart_tg_dep_link *)
                                        calloc(1, sizeof(gs_smart_tg_dep_link));
         
        if(!obj_nodes[gi->tg_fli]->tg_obj_frwrd_link[i]) return -1;
        obj_nodes[gi->tg_fli]->tg_obj_frwrd_link[i]->for_link_pos=i;
     }

     gi->tg_fli++;  
    }
    gi->ap_ai++;  
    }
  }
    
    gi->ap_ai=0;
    gi->tg_fli=0;  

  return 0;
}






int 
gs_smart_tg_construct_backward_links(gs_smart_app_pm * app_pm,  
    gs_smart_tg * task_graph, gs_smart_graph_indexes * gi){

  gs_smart_app_pm_task   * apm_this_node=NULL, * apm_prev_node=NULL;
  gs_smart_tg_remote_task_node * tg_rem_task_node=NULL;
  gs_smart_tg_client_node * tg_client_node=NULL;
  gs_smart_tg_dep_link ** backward_links=NULL;
  int i, nb_backward_links=0;
  gs_smart_tg_task_node * tg_task_node;


  if((!app_pm) || (!task_graph) || (!gi)) return -1;
  if((!app_pm->tasks[gi->ap_ti])) return -1;
  if(!task_graph->task_nodes[gi->tg_ti]) return -1;
  if(gi->ap_ti>0){
    apm_prev_node= app_pm->tasks[gi->ap_ti-1];  
  }

  apm_this_node= app_pm->tasks[gi->ap_ti];  
  tg_task_node=task_graph->task_nodes[gi->tg_ti];
  if(tg_task_node->node_type==GS_SMART_TG_CLIENT_NODE){
    tg_client_node=tg_task_node->tg_client_node;
    if(!tg_client_node) return -1;

    if((gi->tg_ti)==(task_graph->nb_nodes-2)){
      nb_backward_links= apm_this_node->t_anayl->nb_next_client_back_links;
    }
    else if(gi->ap_ti==0){
      nb_backward_links=0;
    }
    else{
      nb_backward_links= apm_prev_node->t_anayl->nb_next_client_back_links;
    }
    tg_client_node->nb_node_bkwd_links=nb_backward_links;   
    
 
    /*
     * Allocating backward links of the client node
     */
    tg_client_node->tg_node_bkwrd_link=(gs_smart_tg_dep_link **)calloc(nb_backward_links, sizeof (gs_smart_tg_dep_link *));
  
    backward_links=tg_client_node->tg_node_bkwrd_link;
    for(i=0; i<nb_backward_links;i++){
      backward_links[i] = (gs_smart_tg_dep_link *)calloc(1, sizeof(gs_smart_tg_dep_link));
      if(!backward_links[i]){
        return -1;
      }
      backward_links[i]->back_link_pos=i;
    }
  }
  else if(tg_task_node->node_type==GS_SMART_TG_REM_TASK_NODE){
    tg_rem_task_node=tg_task_node->tg_rem_task_node;
    nb_backward_links=apm_this_node->t_anayl->nb_task_back_links;

    tg_rem_task_node=tg_task_node->tg_rem_task_node;

    if(!tg_rem_task_node) return -1;
    
    tg_rem_task_node->nb_node_bkwd_links=nb_backward_links;  
 
    /*
     * Allocating backward links of the remote task node 
     */
    tg_rem_task_node->tg_node_bkwrd_link=(gs_smart_tg_dep_link **)
                    calloc(nb_backward_links, sizeof (gs_smart_tg_dep_link *));
 
    backward_links=tg_rem_task_node->tg_node_bkwrd_link;
  
    for(i=0; i<nb_backward_links;i++){
      backward_links[i] = (gs_smart_tg_dep_link *)calloc(1, sizeof(gs_smart_tg_dep_link));
      if(!backward_links[i]){
        return -1;
      }
      backward_links[i]->back_link_pos=i;
    }
  }
  return 0;
}



int
gs_smart_tg_join_for_back_links(gs_smart_app_pm * app_pm,
    gs_smart_tg * task_graph, gs_smart_graph_indexes * gi){


  gs_smart_tg_task_node * tg_task_node;
  if((!app_pm) || (!task_graph) || (!gi) ) return -1;

  tg_task_node=task_graph->task_nodes[gi->tg_ti];

  if(!tg_task_node) return -1;

  if(tg_task_node->node_type==GS_SMART_TG_CLIENT_NODE){
    if(gs_smart_tg_client_node_join_for_back_links(app_pm,task_graph,gi)<0){
      ERRPRINTF("SMART: Error joining client node dependencies links\n");
      return -1;
    }
  }
 
  if(tg_task_node->node_type==GS_SMART_TG_REM_TASK_NODE){
    if(gs_smart_tg_rem_task_join_for_back_links(app_pm,task_graph,gi)<0){
      ERRPRINTF("SMART: Error joining remote  task node dependencies links\n");
      return -1;
    } 
 
  }
  return 0;
}








int 
gs_smart_tg_construct_end_node(gs_smart_tg * task_graph, 
    gs_smart_graph_indexes * gi){

  gs_smart_tg_task_node * tg_task_node; 
  if((!task_graph) || (!gi)) return -1;
 
  if(!task_graph->task_nodes) return -1;
  if(!task_graph->task_nodes[gi->tg_ti]) return -1; 
 
  tg_task_node=task_graph->task_nodes[gi->tg_ti];

  if(!tg_task_node) return -1;

  tg_task_node->node_type=GS_SMART_TG_END_NODE;
  return 0;
}







int gs_smart_tg_dependency_search(gs_smart_app_pm * apm,  
     gs_argument_t *src_argptr,  gs_argument_t **_dest_argptr,    
                                  gs_smart_graph_indexes * gi, int * result){
  

  if((!apm || (!src_argptr) || (!gi))) return ERROR;
  gs_smart_app_pm_task * apm_src_task, * apm_dest_task;
  gs_smart_app_pm_args * apm_src_arg, * apm_dest_arg;
 
  gi->ap_dai=0; 
  gs_argument_t * dest_argptr=NULL;

  *result=ERROR;
  if(!apm->tasks) return -1;
  if((!apm->tasks[gi->ap_sti])) return -1;
  apm_src_task=apm->tasks[gi->ap_sti];

  if(!apm_src_task->args) return -1;
  if(!apm_src_task->args[gi->ap_sai]) return -1;
  apm_src_arg=apm_src_task->args[gi->ap_sai];
  for( gi->ap_dti=gi->ap_dti; gi->ap_dti<apm->nb_tasks; gi->ap_dti++){   
     if(!apm->tasks[gi->ap_dti]) return -1;
     apm_dest_task=apm->tasks[gi->ap_dti];    
    
     if(!apm_dest_task->problem) return -1;
     if(!apm_dest_task->problem->arglist) return -1; 
     dest_argptr= apm->tasks[gi->ap_dti]->problem->arglist;
      gi->ap_dai=0;
      gi->tg_bli=0;
 
     if(!apm->tasks[gi->ap_dti]->args) return -1;

     while( dest_argptr!=NULL ){

       if(dest_argptr->objecttype!=GS_SCALAR){
         if(!apm_dest_task->args[gi->ap_dai]) return -1;
         apm_dest_arg=apm_dest_task->args[gi->ap_dai];
         if((dest_argptr->inout==GS_IN) || (dest_argptr->inout==GS_INOUT)) gi->tg_bli++;

         if(apm_src_arg->id==apm_dest_arg->id){
           if(dest_argptr->inout==GS_IN){
             *_dest_argptr= dest_argptr;
             *result=DEP_FOUND_ARG_NOT_UPDATED;
             return 0;
           }
           if(dest_argptr->inout==GS_INOUT){
             *_dest_argptr= dest_argptr;
             *result=DEP_FOUND_ARG_UPDATED;
             return 0;
           }
          if(dest_argptr->inout==GS_OUT){
             *result=DEP_NOT_FOUND_ARG_UPDATED;
             return 0;
          }
         }
       }
       gi->ap_dai++;
       dest_argptr=dest_argptr->next;
     }
     gi->tg_dti=gi->tg_dti+2;
  }
  *result=DEP_NOT_FOUND_ARG_NOT_UPDATED;
  return 0;
}









int 
gs_smart_tg_dep_anayl_set_remote_dep(gs_smart_t_dep_anayl * src_t_anayl, 
          gs_smart_t_dep_anayl * dest_t_anayl, gs_smart_a_dep_anayl * src_a_anayl, 
          gs_smart_a_dep_anayl * dest_a_anayl, gs_smart_graph_indexes * gi, int inout){

  int obj_for_link;
  if((!src_a_anayl) || (!dest_a_anayl) || (!src_t_anayl) || (!dest_t_anayl)) return -1;
  if(!gi) return -1;

  src_a_anayl->is_sent_remotely=1;
  dest_a_anayl->is_received_remotely=1;
  
  src_a_anayl->out_task_dep=gi->tg_dti;
  src_a_anayl->out_task_dep_link=gi->tg_bli;
  src_a_anayl->out_obj_dep_link=1;

  obj_for_link=src_a_anayl->nb_obj_for_links;   
  dest_a_anayl->in_task_dep=gi->tg_ti;
  dest_a_anayl->in_task_dep_link=gi->tg_fli;
  dest_a_anayl->in_obj_dep_link=obj_for_link;   


  if(inout==GS_IN){
   if(src_a_anayl->nb_clnt_obj_for_links==0){
    src_a_anayl->nb_clnt_obj_for_links++;
 
   }
 
    obj_for_link=src_a_anayl->nb_clnt_obj_for_links;   
    dest_t_anayl->nb_prev_client_for_links--;
    dest_a_anayl->in_task_dep--;
    dest_a_anayl->in_task_dep_link=gi->tg_clnt_fli;
    dest_a_anayl->in_obj_dep_link=obj_for_link;        
    src_a_anayl->nb_clnt_obj_for_links++;
  }
  else{
    src_a_anayl->nb_obj_for_links++;
  }

  if((inout==GS_INOUT) || (inout==GS_OUT) ){
    dest_t_anayl->nb_prev_client_for_links--;
    if((src_a_anayl->nb_obj_for_links==1)){
      src_t_anayl->nb_next_client_back_links--;
    }
  }
  return 0;
}








int
gs_smart_tg_rem_task_join_for_back_links(gs_smart_app_pm * app_pm,
    gs_smart_tg * task_graph, gs_smart_graph_indexes * gi){
  
  gs_argument_t *argptr; 
  gs_smart_app_pm_task  * apm_this_node;
  gs_smart_tg_task_node * tg_task_node;
  gs_smart_tg_remote_task_node * tg_rem_task_node=NULL, * tg_src_rem_task_node=NULL;
   gs_smart_tg_dep_link * for_link, * back_link;
  gs_smart_app_pm_args * apm_this_arg=NULL;
  gs_smart_tg_obj_node * obj_node;
  gs_smart_tg_client_node * tg_src_client_task_node=NULL, * tg_src_clnt_task_node=NULL;

  int src_task;
  int tg_fli;
  int src_clnt_node=0;

 
  if((!app_pm) || (!task_graph) || (!gi) ) return -1;
  if(!task_graph->task_nodes) return -1;

  if(!task_graph->task_nodes[gi->tg_ti]) return -1;

  tg_task_node=task_graph->task_nodes[gi->tg_ti];
  
  if(!tg_task_node->tg_rem_task_node) return -1;

  tg_rem_task_node=tg_task_node->tg_rem_task_node;

 if(!app_pm->tasks) return -1;

 if(!app_pm->tasks[gi->ap_ti]) return -1;
  apm_this_node=app_pm->tasks[gi->ap_ti];

  if(!apm_this_node->problem) return -1;

  if(!tg_rem_task_node->tg_node_bkwrd_link) return -1;
  if(!apm_this_node->args) return -1;

  gi->tg_bli=0;  
  gi->ap_ai=0;
  gi->tg_fli=0;  //previous client node forward link index

  for(argptr=apm_this_node->problem->arglist;argptr!=NULL;argptr=argptr->next){
    if( ((argptr->inout==GS_IN) || (argptr->inout==GS_INOUT)) &&  
                            (argptr->objecttype!=GS_SCALAR)){
      
      if(!tg_rem_task_node->tg_node_bkwrd_link[gi->tg_bli]) return -1;
      
   
      if(!apm_this_node->args[gi->ap_ai]) return -1;      

      apm_this_arg=apm_this_node->args[gi->ap_ai];
 
      
      if(!apm_this_arg->a_anayl) return -1;

      if(apm_this_arg->a_anayl->is_received_remotely){
         src_task=apm_this_arg->a_anayl->in_task_dep;
         tg_fli=apm_this_arg->a_anayl->in_task_dep_link;

         src_clnt_node=0;
         if(task_graph->task_nodes[src_task]->node_type==GS_SMART_TG_CLIENT_NODE) src_clnt_node=1;

         if(src_clnt_node==1){
           if(!task_graph->task_nodes[src_task]->tg_client_node) return -1;
           tg_src_clnt_task_node=task_graph->task_nodes[src_task]->tg_client_node;
           if(!tg_src_clnt_task_node->tg_node_frwrd_link[tg_fli]) return -1;
         
           /*
            * The back link (gi->tg_bli) of this remote task (tg_rem_task_node) 
            * points to object node (obj_node).
            * This object node orignates from source remote task node (tg_src_rem_task_node)
            * forward link (tg_fli) 
            */
            for_link=tg_src_clnt_task_node->tg_node_frwrd_link[tg_fli];
         } 
         else{
           if(!task_graph->task_nodes[src_task]->tg_rem_task_node) return -1;

            tg_src_rem_task_node=task_graph->task_nodes[src_task]->tg_rem_task_node;
         
            if(!tg_src_rem_task_node->tg_node_frwrd_link[tg_fli]) return -1;
           /*
            * The back link (gi->tg_bli) of this remote task (tg_rem_task_node) 
            * points to object node (obj_node).
            * This object node orignates from source remote task node (tg_src_rem_task_node)
            * forward link (tg_fli) 
            */
            for_link=tg_src_rem_task_node->tg_node_frwrd_link[tg_fli];
        }


         if(!for_link->obj_node_ptr) return -1;         

         obj_node=for_link->obj_node_ptr;
                
         
         /*
          * The back link (gi->tg_bli) of this remote task (tg_rem_task_node) 
          * points to object node (obj_node).
          * This object node orignates from source remote task node (tg_src_rem_task_node)
          * forward link (tg_fli) 
          */
                
         /*
          * Initalising parameters of obj_node that the forward link 
          * and backward link point to.
          */
         obj_node->byte_size=gs_smart_get_argument_size(argptr);
         obj_node->argptr=argptr;
         obj_node->name=strdup(obj_node->argptr->name);
         obj_node->in_call_seq_pos=gi->ap_ai; 
         obj_node->rem_dep_id=gi->rem_dep_id;
         gi->rem_dep_id++;          

         /*
          * Initialising the pointer of the two-way forward link of the object node 
          * Pointing it forward to this remote task node (tg_rem_task_node) 
          * and back to itself.
          */ 

         int obj_for_link= apm_this_arg->a_anayl->in_obj_dep_link;
         obj_node->tg_obj_frwrd_link[obj_for_link]->task_node_ptr=tg_task_node;
         obj_node->tg_obj_frwrd_link[obj_for_link]->obj_node_ptr=obj_node;

      
        /*
         * The backlink (tg_bli) of this remote task node (tg_rem_task_node)
         * points back to the object node (obj_node).
         * Therefore it is the reverse of object node forward link (0).
         * As a result the pointers of the two-way backlink (tg_bli) of
         * tg_rem_task_node are the exact same as the two-way foward link (0) of
         * obj_node.
         */

         back_link=obj_node->tg_obj_frwrd_link[obj_for_link];
         tg_rem_task_node->tg_node_bkwrd_link[gi->tg_bli]=back_link;
      }
      else{
         if(!task_graph->task_nodes[gi->tg_ti-1]->tg_client_node) return -1;
         tg_src_client_task_node=task_graph->task_nodes[gi->tg_ti-1]->tg_client_node;
         if(!tg_src_client_task_node->tg_node_frwrd_link[gi->tg_fli]) return -1;

         for_link=tg_src_client_task_node->tg_node_frwrd_link[gi->tg_fli];
         if(!for_link->obj_node_ptr) return -1;         



         /*
          * The back link (gi->tg_bli) of this remote task (tg_rem_task_node) 
          * points to object node (obj_node).
          * This object node originates from source client task node (tg_src_client_node)
          * forward link (tg_fli). 
          */
         obj_node=for_link->obj_node_ptr;
       
         /*
          * Initalising parameters of obj_node that the forward link 
          * and backward link point to.
          */
         obj_node->byte_size=gs_smart_get_argument_size(argptr);
         obj_node->argptr=argptr;
         obj_node->name=strdup(obj_node->argptr->name);
         obj_node->in_call_seq_pos=gi->ap_ai; 
         obj_node->rem_dep_id=-1;
         

         /*
          * Initialising the pointer of the two-way forward link of the object node. 
          * Pointing it forward to this remote task node (tg_rem_task_node) 
          * and back to itself.
          */ 
         int obj_for_link= apm_this_arg->a_anayl->in_obj_dep_link;
         obj_node->tg_obj_frwrd_link[obj_for_link]->task_node_ptr=tg_task_node;
         obj_node->tg_obj_frwrd_link[obj_for_link]->obj_node_ptr=obj_node;
         
        /*
         * The backlink (tg_bli) of this remote task node (tg_rem_task_node)
         * points back to the object node (obj_node).
         * Therefore it is the reverse of object node forward link (0).
         * As a result the pointers of the two-way backlink (tg_bli) of
         * tg_rem_task_node are the exact same as the two-way foward link (0) of
         * obj_node.
         */
         back_link=obj_node->tg_obj_frwrd_link[obj_for_link];

         tg_rem_task_node->tg_node_bkwrd_link[gi->tg_bli]=back_link;
        
        gi->tg_fli++;
      }
          
      gi->tg_bli++; 
        
    }
    gi->ap_ai++;
  } 
  return 0;
}




int
gs_smart_tg_client_node_join_for_back_links(gs_smart_app_pm * app_pm,
    gs_smart_tg * task_graph, gs_smart_graph_indexes * gi){
 
  gs_argument_t *argptr; 
  gs_smart_app_pm_task  * apm_this_node;
  gs_smart_tg_task_node * tg_task_node;
  gs_smart_tg_remote_task_node  * tg_src_rem_task_node=NULL;
  gs_smart_tg_client_node * tg_client_node=NULL;
  gs_smart_tg_dep_link * for_link, * back_link;
  gs_smart_tg_obj_node * obj_node;
  gs_smart_app_pm_args * apm_this_arg=NULL;
  int node_id;
  if((!app_pm) || (!task_graph) || (!gi) ) return -1;

  /*
   * There are no back links if there is only one remote node.
   */
/*
  if(task_graph->nb_nodes==5){
    return 0;
  }
*/

  if(gi->tg_ti==task_graph->nb_nodes-2){ 
    node_id=gi->ap_ti;
  }
  else{
    node_id=gi->ap_ti-1;
  }

  if((!app_pm->tasks) || (!task_graph->task_nodes)) return -1;
  if(!app_pm->tasks[node_id]) return -1;

  apm_this_node=app_pm->tasks[node_id];
 
  if(!task_graph->task_nodes[gi->tg_ti]) return -1;
  tg_task_node=task_graph->task_nodes[gi->tg_ti];

  if(!tg_task_node->tg_client_node) return -1;

  tg_client_node=tg_task_node->tg_client_node;
 
  if((!apm_this_node->args) || (!tg_client_node->tg_node_bkwrd_link)) return -1;

  gi->tg_bli=0;  
  gi->ap_ai=0;
  gi->tg_fli=0;  //previous client node forward link index
  for(argptr=apm_this_node->problem->arglist;argptr!=NULL;argptr=argptr->next){
    if( ((argptr->inout==GS_OUT) || (argptr->inout==GS_INOUT)) &&  (argptr->objecttype!=GS_SCALAR)){   


      if(apm_this_node->args[gi->ap_ai]->a_anayl->is_sent_remotely==0){
      
        
        if(!task_graph->task_nodes[gi->tg_ti-1]->tg_rem_task_node) return -1;

        tg_src_rem_task_node=task_graph->task_nodes[gi->tg_ti-1]->tg_rem_task_node;
       

        if(!tg_src_rem_task_node->tg_node_frwrd_link) return -1; 
        if(!tg_src_rem_task_node->tg_node_frwrd_link[gi->tg_fli]) return -1;

        for_link=tg_src_rem_task_node->tg_node_frwrd_link[gi->tg_fli];

        if(!for_link->obj_node_ptr) return -1;         
         
          /*
          * The back link (gi->tg_bli) of this client node task (tg_client_node) 
          * points to object node (obj_node).
          * This object node originates from source task node (tg_src_rem_task_node)
          * forward link (tg_fli).
          */

         obj_node=for_link->obj_node_ptr;



         /*
          * Initalising parameters of obj_node that the forward link 
          * and backward link point to.
          */
       
         obj_node->byte_size=gs_smart_get_argument_size(argptr);
         obj_node->argptr=argptr;
         obj_node->name=strdup(obj_node->argptr->name);
         //obj_node->call_seq_pos=gi->ap_ai; 
         
         obj_node->rem_dep_id=-1;

         if(!obj_node->tg_obj_frwrd_link[0]) return -1;
         /*
          * Initialising the pointer of the two-way forward link of the object node. 
          * Pointing it forward to this remote task node (tg_rem_task_node) 
          * and back to itself.
          */ 
         apm_this_arg=apm_this_node->args[gi->ap_ai];
         int obj_for_link=0;
         obj_node->tg_obj_frwrd_link[obj_for_link]->task_node_ptr=tg_task_node;
         obj_node->tg_obj_frwrd_link[obj_for_link]->obj_node_ptr=obj_node;

        /*
         * The backlink (tg_bli) of this client node (tg_client_node)
         * points back to the object node (obj_node).
         * Therefore it is the reverse of object node forward link (0).
         * As a result the pointers of the two-way backlink (tg_bli) of
         * tg_client_node are the exact same as the two-way foward link (0) of
         * obj_node.
         */
  
        if(!tg_client_node->tg_node_bkwrd_link[gi->tg_bli]) return -1;
         back_link=obj_node->tg_obj_frwrd_link[obj_for_link];  
         tg_client_node->tg_node_bkwrd_link[gi->tg_bli]=back_link; 
 
        gi->tg_bli++; 
      }
      gi->tg_fli++;
    }
    gi->ap_ai++;
  }
  return 0;
}






int
gs_smart_tg_client_for_links_to_dotgraph(gs_smart_tg_client_node * tg_client_node,int rem_node, FILE * fp){
  gs_smart_tg_dep_link * for_link;
  int j, i;
  for(j=0; j<tg_client_node->nb_node_frwd_links; j++){
    for_link=tg_client_node->tg_node_frwrd_link[j];
    fprintf(fp, "%s_%d_%d [label=\"%s\\nbytes=%d\" ];\n", for_link->obj_node_ptr->name, rem_node, j, for_link->obj_node_ptr->name, for_link->obj_node_ptr->byte_size);
    fprintf(fp, "client_%d -> %s_%d_%d;\n", rem_node, for_link->obj_node_ptr->name, rem_node, j);
    for(i=0;i<for_link->obj_node_ptr->nb_obj_frwd_links;i++){
      fprintf(fp, "%s_%d_%d -> %s_%d;\n",  for_link->obj_node_ptr->name, rem_node, j, for_link->obj_node_ptr->tg_obj_frwrd_link[i]->task_node_ptr->tg_rem_task_node->problem->name, for_link->obj_node_ptr->tg_obj_frwrd_link[i]->task_node_ptr->id);
    }
  }

  return 0;
}










int
gs_smart_tg_rem_for_links_to_dotgraph(gs_smart_tg_remote_task_node * tg_rem_task_node,int rem_node, FILE * fp, int * client_comm_exists){

  gs_smart_tg_task_node * tg_dest_task_node;
  gs_smart_tg_dep_link * for_link;
  gs_smart_tg_client_node * tg_dest_client_node; 
  gs_smart_tg_remote_task_node * tg_dest_rem_task_node;
  int node_type, j, i;
  *client_comm_exists=0;
  
  for(j=0; j<tg_rem_task_node->nb_node_frwd_links; j++){
    for_link=tg_rem_task_node->tg_node_frwrd_link[j];
     tg_dest_task_node=for_link->obj_node_ptr->tg_obj_frwrd_link[0]->task_node_ptr;
     fprintf(fp, " %s_%d_%d [label=\"%s\\nbytes=%d\" ];\n", for_link->obj_node_ptr->name, rem_node, j,  for_link->obj_node_ptr->name, for_link->obj_node_ptr->byte_size);
     fprintf(fp, "%s_%d -> %s_%d_%d;\n", tg_rem_task_node->problem->name, rem_node, for_link->obj_node_ptr->name, rem_node,  j);

     node_type=tg_dest_task_node->node_type;

     if(node_type==GS_SMART_TG_CLIENT_NODE){
       tg_dest_client_node=tg_dest_task_node->tg_client_node;
       for(i=0;i<for_link->obj_node_ptr->nb_obj_frwd_links;i++){
         fprintf(fp, "%s_%d_%d -> client_%d;\n",  for_link->obj_node_ptr->name, rem_node, j, for_link->obj_node_ptr->tg_obj_frwrd_link[i]->task_node_ptr->id);
         *client_comm_exists=1;
       }
     }
     else if(node_type==GS_SMART_TG_REM_TASK_NODE){
       tg_dest_rem_task_node=tg_dest_task_node->tg_rem_task_node;
       for(i=0;i<for_link->obj_node_ptr->nb_obj_frwd_links;i++){
         fprintf(fp, "%s_%d_%d -> %s_%d;\n",  for_link->obj_node_ptr->name, rem_node, j, for_link->obj_node_ptr->tg_obj_frwrd_link[i]->task_node_ptr->tg_rem_task_node->problem->name, for_link->obj_node_ptr->tg_obj_frwrd_link[i]->task_node_ptr->id);
       }
     } 
   }
  return 0;
}







int gs_smart_reset_graph_indexes(gs_smart_graph_indexes * gi){
  if(!gi){
    ERRPRINTF("Smart : Error allocating graph indexes\n");
    return -1;
  }
  gi->cur_arg_id=0;
  gi->tg_ti=0;
  gi->tg_sti=0; 
  gi->tg_dti=0;
  gi->tg_lnai=0; 
  gi->tg_rnai=0;
  gi->tg_drnai=0; 

  gi->ap_ti=0;
  gi->ap_sti=0;  
  gi->ap_dti=0;  
  gi->ap_sai=0; 
  gi->ap_dai=0; 


  return 0;
}








int gs_smart_tg_set_scalar_arg_values(gs_smart_app_pm * apm, icl_hash_t *symtab, gs_smart_graph_indexes * gi){
  gs_smart_app_pm_task * apm_task; 
  gs_smart_app_pm_args * apm_arg;
  gs_argument_t *argptr;
  int ai=0;


  if((!apm) || (!symtab) || (!gi)) return -1;
 
  apm_task=apm->tasks[gi->ap_ti];

  if(!apm_task){
    ERRPRINTF("Smart : Error finding apm task node %d\n", gi->ap_ti);
    return -1;
  }

  if(!apm_task->problem->arglist){
    ERRPRINTF("Smart : Error, arglist for apm task node %d is NULL\n",  gi->ap_ti);
    return -1;
  }


  for(argptr= apm_task->problem->arglist;argptr!=NULL;argptr=argptr->next){
    if((argptr->objecttype==GS_SCALAR) && ((argptr->inout == GS_IN) || 
        (argptr->inout == GS_INOUT)) ){

      apm_arg= apm_task->args[ai];
      if(apm_arg->scalar){
        switch(argptr->datatype) {
          case GS_INT:
            argptr->expr_val = (int) apm_arg->uvalue.i;; 
          break;
          case GS_CHAR:
            argptr->expr_val = (char) apm_arg->uvalue.c;
          break;
          case GS_FLOAT:
            argptr->expr_val = (double) *((float *)(argptr->data));
          break;
          case GS_DOUBLE:
            argptr->expr_val = (double) apm_arg->uvalue.d;
          break;
          case GS_SCOMPLEX:
            argptr->expr_val = (double) ((gs_scomplex *)(argptr->data))->r;
          break;
          case GS_DCOMPLEX:
            argptr->expr_val = (double) ((gs_dcomplex *)(argptr->data))->r;
          break;
          default:
            ERRPRINTF("Bad data type\n");
          return -1;
        }
        icl_hash_insert(symtab,argptr->name, &(argptr->expr_val));
      }
      else if ((argptr->objecttype==GS_SCALAR) && (argptr->inout == GS_OUT ) ){
        argptr->expr_val = 0.0;
        icl_hash_insert(symtab, argptr->name, &(argptr->expr_val)); 
        return -1;
      }
    }
    ai++;
  }
  return 0;
}

   


















int gs_smart_tg_get_problem_size(gs_problem_t * problem, double * nb_flops){
  char *complexitystr = NULL;
  double complexity = -1.0;
  gs_argument_t *argptr;
  icl_hash_t *symtab;
  
 if(!problem){
    ERRPRINTF("SMART: Problem is NULL\n");
    return -1;
  }

  symtab = icl_hash_create(11, NULL);

  if(!symtab) {
    LOGPRINTF("SMART: could not create hash table; ");
    LOGPRINTF("assuming complexity=1000000 (1 gflop of work)\n");
    *nb_flops = 1000.0;
  }
  else {
    if(!problem->arglist){
      ERRPRINTF("Smart : Error, the arglist for problem is NULL\n");
      return -1;
    }

    for(argptr = problem->arglist; argptr != NULL; argptr = argptr->next){
      if((argptr->objecttype == GS_SCALAR) && (argptr->inout != GS_OUT)){
      icl_hash_insert(symtab, argptr->name, &(argptr->expr_val));
      }
    }
    // Evaluate complexity expression 
    complexitystr = gs_problem_getinfo(problem, "COMPLEXITY", "1000000");
    if(gs_expr_d(complexitystr, &complexity, symtab) < 0) {
      LOGPRINTF("Complexity string %s could not be evaluated; ", complexitystr);
      LOGPRINTF("assuming complexity=1000000 (1 gflop of work)\n");
    complexity = 1000000.00;    // a gigaflop of work 
    }
    *nb_flops= complexity / 1000.0;
  }
  return 0;
}









/*
Given an argument structure this function returns argument size
*/

int gs_smart_get_argument_size(gs_argument_t * arg){
  int my_dsig;
  if(!arg){
    ERRPRINTF("SMART: Argument pointer is NULL\n");
    return -1;
  }
  my_dsig = pvmgetdsig();
  return (arg->rows * arg->cols * gs_get_element_size(arg->datatype, my_dsig));
}






int gs_smart_tg_free(gs_smart_tg * task_graph){

  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_tg_client_node * tg_client_node;
  gs_smart_tg_dep_link * for_task_link, * back_task_link;
  gs_smart_tg_dep_link * for_obj_link, * back_obj_link;
  gs_smart_tg_obj_node * obj_node;
  int i, j, k, nb_node_for_links,nb_node_back_links;
  int nb_obj_for_links;
  if(!task_graph) return -1;
  for(i=0; i<task_graph->nb_nodes; i++){
    if(!task_graph->task_nodes[i]) return -1;

    if(task_graph->task_nodes[i]->id==GS_SMART_TG_REM_TASK_NODE){


      if(!task_graph->task_nodes[i]->tg_rem_task_node) return -1;

      tg_rem_task_node=task_graph->task_nodes[i]->tg_rem_task_node;
      nb_node_for_links=tg_rem_task_node->nb_node_frwd_links;

      for(j=0; j<nb_node_for_links; j++){

        if(!tg_rem_task_node->tg_node_frwrd_link[j]) return -1;

        for_task_link=tg_rem_task_node->tg_node_frwrd_link[j];

        if(!for_task_link->obj_node_ptr) return -1;
        obj_node=for_task_link->obj_node_ptr;

        nb_obj_for_links=obj_node->nb_obj_frwd_links;
        for(k=0;k<nb_obj_for_links;k++){
          if(!obj_node->tg_obj_frwrd_link[k]) return -1;
          for_obj_link=obj_node->tg_obj_frwrd_link[k];
          if(for_obj_link) free(for_obj_link);

        }
       
        if(!obj_node->tg_obj_bkwrd_link) return -1;

        back_obj_link=obj_node->tg_obj_bkwrd_link;
        if(back_obj_link) free(back_obj_link);

        if(obj_node->name) free(obj_node->name);

        if(obj_node) free(obj_node);
        
      }

      nb_node_back_links=tg_rem_task_node->nb_node_bkwd_links;
      if(tg_rem_task_node) free(tg_rem_task_node);  

    }

    else if(task_graph->task_nodes[i]->id==GS_SMART_TG_CLIENT_NODE){
      if(!task_graph->task_nodes[i]->tg_client_node) return -1;
      tg_client_node=task_graph->task_nodes[i]->tg_client_node;
      nb_node_for_links=tg_client_node->nb_node_frwd_links;
      
      for(j=0; j<nb_node_for_links; j++){
        if(!tg_client_node->tg_node_frwrd_link[j]) return -1;

        for_task_link=tg_client_node->tg_node_frwrd_link[j];
        if(!for_task_link->obj_node_ptr) return -1;
        obj_node=for_task_link->obj_node_ptr;

        nb_obj_for_links=obj_node->nb_obj_frwd_links;
        
        for(k=0;k<nb_obj_for_links;k++){
          if(!obj_node->tg_obj_frwrd_link[k]) return -1;
          for_obj_link=obj_node->tg_obj_frwrd_link[k];
          if(for_obj_link) free(for_obj_link);
        }

        if(!obj_node->tg_obj_bkwrd_link) return -1;
        back_obj_link=obj_node->tg_obj_bkwrd_link;
        if(back_obj_link) free(back_obj_link);

        if(obj_node->name) free(obj_node->name);

        if(obj_node) free(obj_node);
      }
      nb_node_back_links=tg_client_node->nb_node_bkwd_links;

      for(j=0; j<nb_node_back_links; j++){
        if(!tg_client_node->tg_node_bkwrd_link[j]) return -1;
        back_task_link=tg_client_node->tg_node_bkwrd_link[j];
        if(back_task_link) free(back_task_link);
      }
      if(tg_client_node) free(tg_client_node);  
      
    }
    if(task_graph->task_nodes[i]) free(task_graph->task_nodes[i]);
  }
  if(task_graph->task_nodes) free(task_graph->task_nodes);
  if(task_graph) free(task_graph);
  return 0;
}








int 
gs_smart_tg_print_to_dotgraph(gs_smart_tg * task_graph, char * filename){
  gs_smart_tg_task_node * tg_task_node, * tg_next_task_node; 
  gs_smart_tg_remote_task_node * tg_rem_task_node, * tg_next_rem_task_node;
  gs_smart_tg_client_node * tg_client_node, * tg_next_client_node;
  FILE *fp;
  int i, node_type, client_comm_exists;

  fp = fopen(filename, "w");
  if(fp<0){
    ERRPRINTF("SMART: Error opening file\n");
    return -1;
  } 

  fprintf(fp, "digraph Task_Graph {\n");
  for(i=0; i<task_graph->nb_nodes;i++){
    tg_task_node=task_graph->task_nodes[i];
    node_type=tg_task_node->node_type;
    if(node_type==GS_SMART_TG_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_TG_END_NODE){
      fprintf(fp, " end_node_%d [shape=polygon, label=\"end_node_%d\",sides=5, peripheries=2, style=\"filled\", fillcolor=\"#FFA500\" fontsize=\"15.0\"];\n", i, i);
      fprintf(fp, " client_%d -> end_node_%d [color=red];\n", i-1, i);
      break;
    }
    else if(node_type==GS_SMART_TG_CLIENT_NODE){
      tg_client_node=tg_task_node->tg_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){
      tg_rem_task_node=tg_task_node->tg_rem_task_node;
      if(tg_rem_task_node->blocking==0){
        fprintf(fp, " %s_%d [shape=box,label=\"%s_%d\\nblocking=%d\\nflops=%f\",  style=filled,fillcolor=\"gray80\",fontsize=15.0];\n", tg_rem_task_node->problem->name, i, tg_rem_task_node->problem->name, i, tg_rem_task_node->blocking, tg_rem_task_node->nb_flops);

      }
      else
      {
        fprintf(fp, " %s_%d [shape=box,label=\"%s_%d\\nblocking=%d\\nflops=%f\",  style=filled,fillcolor=\"gray60\",fontsize=15.0];\n", tg_rem_task_node->problem->name, i, tg_rem_task_node->problem->name, i, tg_rem_task_node->blocking, tg_rem_task_node->nb_flops);
      }
    }
  }

  for(i=0; i<task_graph->nb_nodes;i++){
    tg_task_node=task_graph->task_nodes[i];
    node_type=tg_task_node->node_type;
    if(node_type==GS_SMART_TG_END_NODE){

      fprintf(fp, " start_node_0 -> client_1 [color=red];\n");
      break;
    }
    else if(node_type==GS_SMART_TG_CLIENT_NODE){
      tg_client_node=tg_task_node->tg_client_node;

      if(tg_client_node->nb_node_frwd_links==0){
        tg_next_task_node=task_graph->task_nodes[i+1]; 
        node_type=tg_next_task_node->node_type;
        if(node_type==GS_SMART_TG_REM_TASK_NODE){
          tg_next_rem_task_node=task_graph->task_nodes[i+1]->tg_rem_task_node;
          fprintf(fp, " client_%d -> %s_%d [style=dotted color=red];\n", i, tg_next_rem_task_node->problem->name, i+1);
        
        }
      }
      if(gs_smart_tg_client_for_links_to_dotgraph(tg_client_node, i, fp)<0){
        ERRPRINTF("SMART: Error printing client node\n");
        return -1;
      }
    }
    else if(node_type==GS_SMART_TG_REM_TASK_NODE){
      tg_rem_task_node=tg_task_node->tg_rem_task_node;
      
      if(gs_smart_tg_rem_for_links_to_dotgraph(tg_rem_task_node, i, fp, &client_comm_exists)<0){
        ERRPRINTF("SMART: Error printing remote task node\n");
        return -1;
      }
      if(!client_comm_exists){
        tg_next_task_node=task_graph->task_nodes[i+1];
        node_type=tg_next_task_node->node_type;
        if(node_type==GS_SMART_TG_CLIENT_NODE){
          tg_next_client_node=task_graph->task_nodes[i+1]->tg_client_node;
          fprintf(fp, " %s_%d -> client_%d [style=dotted color=red];\n",  tg_rem_task_node->problem->name, i, i+1);
        }
      }
    }
  }
  fprintf(fp, "\n}\n");

  fclose(fp);
  return 0;
}



#endif