comm_encode.c

Go to the documentation of this file.

/* $Id: comm_encode.c,v 1.77 2008/12/11 02:06:24 tbrady Exp $ */
/* $UTK_Copyright: $ */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "comm_encode.h"
#include "comm_data.h"
#include "utility.h"

int
gs_encode_cancel_notification(char **msg,
  char *server_cid, char *request_id, int agent_taskid)
{ 
  if(!server_cid || !request_id) {
    *msg = NULL;
    return -1;
  }

  *msg = dstring_sprintf("%s %s %d", server_cid, request_id, agent_taskid);

  return 0;
}

int
gs_decode_cancel_notification(char *msg,
  char **server_cid, char **request_id, int *agent_taskid)
{
  if(!msg)
    return -1;

  sscanf(msg, "%s %s %d", *server_cid, *request_id, agent_taskid);
  return 0;
}

int
gs_encode_failure_notification(char **msg,
  char *server_cid, char *request_id, int agent_taskid)
{ 
  if(!server_cid || !request_id) {
    *msg = NULL;
    return -1;
  }

  *msg = dstring_sprintf("%s %s %d", server_cid, request_id, agent_taskid);

  return 0;
}

int
gs_decode_failure_notification(char *msg,
  char **server_cid, char **request_id, int *agent_taskid)
{
  if(!msg)
    return -1;

  sscanf(msg, "%s %s %d", *server_cid, *request_id, agent_taskid);
  return 0;
}

int
gs_encode_problem_complete_notification(char **msg,
  char *server_cid, char *request_id, int agent_taskid, double run_time)
{ 
  if(!server_cid || !request_id) {
    *msg = NULL;
    return -1;
  }

  *msg = dstring_sprintf("%s %s %d %lf", server_cid, request_id, agent_taskid,
     run_time);

  return 0;
}

int
gs_decode_problem_complete_notification(char *msg,
  char **server_cid, char **request_id, int *agent_taskid, double *run_time)
{
  if(!msg)
    return -1;

  sscanf(msg, "%s %s %d %lf", *server_cid, *request_id, agent_taskid, run_time);
  return 0;
}

int
gs_encode_problem_solve_notification(char **msg, char *problem_name, 
  double est_time, char *server_cid, char *user_name,
  char *host_name, char *client_cid, char *request_id, int agent_taskid,
  double agent_est_time)
{
  if(!problem_name) {
    *msg = NULL;
    return -1;
  }

  *msg = dstring_sprintf("%s %lf %s %s %s %s %s %d %lf", problem_name, est_time,
     server_cid, user_name, host_name, client_cid, request_id, agent_taskid,
     agent_est_time);

  return 0;
}

int
gs_decode_problem_solve_notification(char *msg, char **problem_name,
  double *est_time, char **server_cid, char **user_name,
  char **host_name, char **client_cid, char **request_id, int *agent_taskid,
  double *agent_est_time)
{
  if(!msg)
    return -1;

  *problem_name = CALLOC(strlen(msg), sizeof(char));
  *server_cid = CALLOC(strlen(msg), sizeof(char));
  *user_name = CALLOC(strlen(msg), sizeof(char));
  *host_name = CALLOC(strlen(msg), sizeof(char));
  *client_cid = CALLOC(strlen(msg), sizeof(char));
  *request_id = CALLOC(strlen(msg), sizeof(char));

  sscanf(msg, "%s %lf %s %s %s %s %s %d %lf", *problem_name, est_time, *server_cid,
    *user_name, *host_name, *client_cid, *request_id, agent_taskid, agent_est_time);

  return 0;
}

int 
gs_encode_problem_solve_request(char **msg, char *problem_name, 
  char *user_name, char *host_name, char *domain_name, char *client_cid, 
  int dsig, int agent_taskid, double agent_est_time)
{
  if(!problem_name) {
    *msg = NULL;
    return -1;
  }
   
  *msg = dstring_sprintf("%s %s %s.%s %s %d %d %lf ", problem_name, user_name,
     host_name, domain_name, client_cid, dsig, agent_taskid, agent_est_time);
  
  return 0;
}

int 
gs_decode_problem_solve_request(char *msg, char **problem_name, 
  char **user_name, char **full_host_name, char **client_cid, int *dsig,
  int *agent_taskid, double *agent_est_time)
{
  if(!msg)
    return -1;

  sscanf(msg, "%s %s %s %s %d %d %lf", *problem_name, *user_name, *full_host_name, 
    *client_cid, dsig, agent_taskid, agent_est_time);
  return 0;
}

int
gs_decode_problem_submit_request(char *msg, char **problem_name, int *dsig, char **criteria)
{
  int nchars;
  
  if(!msg)
    return -1;
    
  /* since the message consists of only the problem name, we
   * just dup it and return.
   */
  *problem_name = (char *)CALLOC(strlen(msg), sizeof(char));
  sscanf(msg, "%s %d %n", *problem_name, dsig, &nchars);
  
  if(msg[nchars] != 0) {
    *criteria = strdup(msg + nchars);
    
    if(!*criteria) {
      printf("failed to alloc criteria\n");
      return -1;
    }
  } 
  else
    *criteria = NULL;

  return 0;
}

int 
gs_encode_problem_submit_request(char **msg, char *problem_name, int dsig, char *criteria)
{
  if(!problem_name) 
    return -1;

  *msg = dstring_sprintf("%s %d %s", problem_name, dsig, criteria ? criteria : "");

  return 0;
}

int 
gs_encode_problem_submit_response(char **msg, char **server_list, int num_servers)
{
  int i;

  if(!server_list) 
    return -1;

  *msg = dstring_sprintf("%d ", num_servers);

  for(i=0;i<num_servers;i++) {

    *msg = dstring_append(*msg, server_list[i]);
    *msg = dstring_append(*msg, " ");
  }

  return 0;
}

int 
gs_decode_problem_submit_response(char *msg, char ***server_list, int *num_servers)
{
  int i;

  if(!msg) 
    return -1;

  *num_servers = atoi(strtok(msg, " "));

  *server_list = (char **)CALLOC(*num_servers, sizeof(char *));

  if(!*server_list) {
    ERRPRINTF("decodeProblemSubmitResponse: malloc failed\n");
    return -1;
  }

  for(i=0;i<*num_servers;i++) 
    (*server_list)[i] = strdup(strtok(NULL," " ));

  return 0;
}

int
gs_decode_model_update(char *strp, char **name, char **expr)
{
  int maxlen;
  
  maxlen = strlen(strp);
  
  *name = (char *)calloc(maxlen, sizeof(char));
  if(!*name) return -1;
  
  *expr = (char *)calloc(maxlen, sizeof(char));
  if(!*expr) return -1;
  
  sscanf(strp, "<model_update prob_name=\"%[^\"]\" expr=\"%[^\"]\"/>\n",
          *name, *expr);

  return 0;
}

int
gs_encode_model_update(char **s, char *name, char *expr)
{
  *s = dstring_sprintf("<model_update prob_name=\"%s\" expr=\"%s\"/>\n",
          name, expr);

  return *s ? 0 : -1;
}

int 
gs_encode_infolist(char **s, gs_info_t *list)
{
  int count = 0;
  char *stmp = NULL;
  gs_info_t* info = NULL;

  for (count=0,info=list; info!=NULL; info=info->next) 
    count++;

  stmp = dstring_sprintf(" <infolist count=\"%d\">\n", count);
  *s = dstring_append_free(*s, stmp);


  for (info=list; info!=NULL; info=info->next) {
    stmp = dstring_sprintf("  <info type=\"%s\" value=\"%s\" />\n", info->type, info->value);
    *s = dstring_append_free(*s, stmp);
  }
  stmp = dstring_sprintf(" </infolist>\n");

  *s = dstring_append_free(*s, stmp);

  return 0;
}

int 
gs_decode_infolist(char *strp, gs_info_t **list)
{
  int n, nchars, count, idx, maxlen;
  gs_info_t *info, *ip;

  maxlen = strlen(strp);

  n = sscanf(strp, " <infolist count=\"%d\">\n %n", &count, &nchars);
  strp = strp+nchars;   /* move past processed chars */

  for (nchars=0, idx=0; idx<count; idx++) {
    info = (gs_info_t*)CALLOC(1, sizeof(gs_info_t));
    if(!info) return -1;

    info->next = NULL;

    info->type = (char *)CALLOC(maxlen, sizeof(char));
    if(!info->type) return -1;

    info->value = (char *)CALLOC(maxlen, sizeof(char));
    if(!info->value) return -1;

    n = sscanf(strp, "  <info type=\"%[^\"]\" value=\"%[^\"]\" />\n %n", 
          info->type, info->value, &nchars);

    strp = strp+nchars; /* move past processed chars */
    info->type = REALLOC(info->type, strlen(info->type)+1);
    info->value = REALLOC(info->value, strlen(info->value)+1);

    if(!info->type || !info->value) return -1;

    if (*list == NULL)
      *list = info;
    else {
      for (ip=*list; ip->next!=NULL; ip=ip->next) {}
      ip->next = info;
    }
  }
  n = sscanf(strp, " </infolist>\n %n", &nchars);
  strp = strp+nchars;   /* move past processed chars */

  return 0;
}

int
gs_encode_smart_info(char **encoding, gs_server_t *server, gs_server_t **server_list, double *times, int count){

  char componentid_string[CID_LEN*2+1];
  char *stmp = NULL;
  int i;    
  gs_server_t **s = server_list;   /* just a shortcut name */
  *encoding = dstring_sprintf("<smart_info>\n");
  stmp = dstring_sprintf("<count> %d </count>\n", count);
  *encoding = dstring_append_free(*encoding , stmp);

  for(i=0;i<count;i++){
    if(!s[i]){
      return -1;
    }
    proxy_cid_to_str(componentid_string, s[i]->componentid);
    stmp = dstring_sprintf("<componentid> %s </componentid>  <time> %f </time> \n", componentid_string, times[i]);
    *encoding = dstring_append_free(*encoding, stmp);
  }
   stmp = dstring_sprintf("</smart_info>");
   *encoding = dstring_append_free(*encoding, stmp);
  return 0;
}

int
gs_decode_smart_info(char *encoding, gs_server_pings_t ***pings, int *np)
{
  int i, n, count, maxlen, nchars;
  gs_server_pings_t **parr;
  char *strp, *cid_tmp;

  *np = 0;
  *pings = NULL;

  strp = encoding;
  maxlen = strlen(strp);

  cid_tmp = (char *)calloc(maxlen, sizeof(char));
  if(!cid_tmp) return -1;

  n = sscanf(strp, "<smart_info>\n %n", &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<count> %d </count>\n %n", &count, &nchars);
  strp = strp+nchars;

  parr = (gs_server_pings_t **) malloc(count * sizeof(gs_server_pings_t *));
  if(!parr) {
    free(cid_tmp);
    return -1;
  }

  for(i=0;i<count;i++) {
    parr[i] = (gs_server_pings_t *) malloc(sizeof(gs_server_pings_t));
    if(!parr[i]) {
      /* probably need to free parr[1 through i-1] too */
      free(parr);
      free(cid_tmp);
      return -1;
    }

    n = sscanf(strp, "<componentid> %s </componentid>  <time> %lg </time>\n %n",
          cid_tmp, &(parr[i]->comm_time), &nchars);
    strp = strp+nchars;
    proxy_str_to_cid(parr[i]->componentid, cid_tmp);
  }

  n = sscanf(strp, "</smart_info>\n %n", &nchars);
  strp = strp+nchars;

  *np = count;
  *pings = parr;

  return 0;
}

int 
gs_encode_server(char **encoding, gs_server_t *gs_server) 
{
  gs_server_t *s = gs_server;   /* just a shortcut name */
  char componentid_string[CID_LEN*2+1], server_dottedIP[20], 
    proxy_dottedIP[20];

  if(!gs_server)
    return -1;

  proxy_cid_to_str(componentid_string, s->componentid);
  proxy_ip_to_str(s->ipaddress, server_dottedIP);
  proxy_ip_to_str(s->proxyip, proxy_dottedIP);

  *encoding = dstring_sprintf("<server> <hostname> %s </hostname> <ipaddress> %s </ipaddress> <port> %hu </port> <proxyip> %s </proxyip> <proxyport> %hu </proxyport> <componentid> %s </componentid> <arch> %s </arch> <data_format> %d </data_format> <kflops> %d </kflops> <workload> %d </workload> <ncpu> %d </ncpu> <status> %d </status> <availcpu> %lg </availcpu> <availmem> %lg </availmem> <nproblems> %d </nproblems> <agenthost> %s </agenthost> <agentport> %d </agentport> <score> %g </score> <smart> %d </smart> </server>\n", s->hostname, server_dottedIP, s->port, proxy_dottedIP, s->proxyport, componentid_string, s->arch, s->data_format, s->kflops, s->workload, s->ncpu, s->status, s->availcpu, s->availmem, s->nproblems, s->agenthost, s->agentport, s->score, s->smart);

  if(gs_encode_infolist(encoding,s->sa_list) < 0)
    return -1;
 /* 
#ifdef GS_SMART_GRIDSOLVE
   *encoding = dstring_sprintf("<smart_info>");
   int i =0;
   int numSmartServers;
   for (i=0; i<numSmartServers; i++) {
     *encoding = dstring_sprintf("<componentid> %s </componentid>  <time> %f </time> \n", server[i]->comp_id, server[i]->time);
   }
  *encoding = dstring_sprintf("</smart_info>");
#endif
  */

  DBGPRINTF("server strlen %d encoding %s\n", (int)(strlen(*encoding)), *encoding);
  return 0;
}

int 
gs_decode_server(char *encoding, gs_server_t *gs_server)
{
  int rv = -1, nchars;
  gs_server_t *s = gs_server;  
  char componentid_string[CID_LEN*2+1], server_dottedIP[20], 
    proxy_dottedIP[20];

  if(!encoding)
    return -1;

  s->hostname = (char *)CALLOC(strlen(encoding)+1, sizeof(char));
  s->arch = (char *)CALLOC(strlen(encoding)+1, sizeof(char));
  s->agenthost = (char *)CALLOC(strlen(encoding)+1, sizeof(char));

  if(!s->hostname || !s->arch || !s->agenthost) {
    if(s->hostname) free(s->hostname);
    if(s->arch) free(s->arch);
    if(s->agenthost) free(s->agenthost);
    return -1;
  }

  rv = sscanf(encoding, "<server> <hostname> %s </hostname> <ipaddress> %s </ipaddress> <port> %hu </port> <proxyip> %s </proxyip> <proxyport> %hu </proxyport> <componentid> %s </componentid> <arch> %s </arch> <data_format> %d </data_format> <kflops> %d </kflops> <workload> %d </workload> <ncpu> %d </ncpu> <status> %d </status> <availcpu> %lg </availcpu> <availmem> %lg </availmem> <nproblems> %d </nproblems> <agenthost> %s </agenthost> <agentport> %d </agentport> <score> %lg </score> <smart> %d </smart> </server>\n %n", s->hostname, server_dottedIP, &s->port, proxy_dottedIP, &s->proxyport, componentid_string, s->arch, &s->data_format, &s->kflops, &s->workload, &s->ncpu, &s->status, &s->availcpu, &s->availmem, &s->nproblems, s->agenthost, &s->agentport, &s->score, &s->smart, &nchars);

  if (rv != 19) {
    ERRPRINTF("Server decoding '%s' failed with %d items decoded \n", 
      encoding, rv);
    FREE(s->hostname);
    FREE(s->arch);
    FREE(s->agenthost);
    return -1;
  }

  s->sa_list = NULL;
  
  encoding += nchars;
  gs_decode_infolist(encoding,&s->sa_list);

  s->hostname = REALLOC(s->hostname, strlen(s->hostname)+1);
  s->arch = REALLOC(s->arch, strlen(s->arch)+1);
  s->agenthost = REALLOC(s->agenthost, strlen(s->agenthost)+1);

  if(!s->hostname || !s->arch || !s->agenthost) {
    ERRPRINTF("Server decoding failed to realloc memory\n");
    FREE(s->hostname);
    FREE(s->arch);
    FREE(s->agenthost);
    return -1;
  }

  proxy_str_to_cid(s->componentid, componentid_string);
  proxy_str_to_ip(&s->ipaddress, server_dottedIP);
  proxy_str_to_ip(&s->proxyip, proxy_dottedIP);

  return 0;
}

int 
gs_encode_availability_request(char **encoding, gs_server_t *gs_server) 
{
  gs_server_t *s = gs_server;   /* just a shortcut name */
  char componentid_string[CID_LEN*2+1], server_dottedIP[20], 
    proxy_dottedIP[20];

  if(!gs_server)
    return -1;

  proxy_cid_to_str(componentid_string, s->componentid);
  proxy_ip_to_str(s->ipaddress, server_dottedIP);
  proxy_ip_to_str(s->proxyip, proxy_dottedIP);

  *encoding = dstring_sprintf("<conn_test> <ipaddress> %s </ipaddress> <port> %hu </port> <proxyip> %s </proxyip> <proxyport> %hu </proxyport> <componentid> %s </componentid> </conn_test>\n", server_dottedIP, s->port, proxy_dottedIP, s->proxyport, componentid_string);

  return 0;
}

int 
gs_decode_availability_request(char *encoding, gs_server_t *gs_server)
{
  int rv = -1, nchars;
  gs_server_t *s = gs_server;  
  char componentid_string[CID_LEN*2+1], server_dottedIP[20], 
    proxy_dottedIP[20];

  if(!encoding)
    return -1;

  rv = sscanf(encoding, "<conn_test> <ipaddress> %s </ipaddress> <port> %hu </port> <proxyip> %s </proxyip> <proxyport> %hu </proxyport> <componentid> %s </componentid> </conn_test>\n %n", server_dottedIP, &s->port, proxy_dottedIP, &s->proxyport, componentid_string, &nchars);

  if (rv != 5) {
    ERRPRINTF("Server decoding '%s' failed with %d items decoded \n", 
      encoding, rv);
    return -1;
  }

  s->sa_list = NULL;
  
  proxy_str_to_cid(s->componentid, componentid_string);
  proxy_str_to_ip(&s->ipaddress, server_dottedIP);
  proxy_str_to_ip(&s->proxyip, proxy_dottedIP);

  return 0;
}

int 
gs_encode_workload_report(char **msg, int workload, int nproblems,
  char *server_cid)
{
  if(!server_cid)
    return -1;

  *msg = dstring_sprintf("%d %d %s", workload, nproblems, server_cid);

  return 0;
}

int 
gs_decode_workload_report(char *msg, int *workload, int *nproblems,
  char *server_cid)
{
  if(!msg)
    return -1;

  sscanf(msg, "%d %d %s", workload, nproblems, server_cid);

  return 0;
}

int 
gs_encode_problem(char **problemstring, gs_problem_t* problem) 
{
  int count = 0, enum_count = 0;
  gs_argument_t *arg = NULL;
  gs_arg_enum_t *arg_enum = NULL;
  char *s = NULL;
  char *stmp = NULL;
  char *callsig;

  if(!problem)
    return -1;
  
  callsig = problem->callsig ? problem->callsig : GS_NO_CALL_SIG;

  s = dstring_sprintf("<problem name=\"%s\" type=\"%s\" description=\"%s\" major=\"%d\" callsig=\"%s\">\n", problem->name, gs_probtype[problem->type], problem->description, problem->major, callsig);

  for (count=0,arg=problem->arglist; arg!=NULL; arg=arg->next) 
    count++;

  stmp = dstring_sprintf(" <arglist count=\"%d\">\n", count);
  s = dstring_append_free(s,stmp);

  for (arg=problem->arglist; arg!=NULL; arg=arg->next) {
    for (enum_count=0,arg_enum=arg->arg_enum; arg_enum!=NULL; arg_enum=arg_enum->next) 
      enum_count++;

    stmp = dstring_sprintf("  <arg name=\"%s\" inout=\"%s\" datatype=\"%s\" objecttype=\"%s\" rowexp=\"%s\" colexp=\"%s\" nnzexp=\"%s\" indices=\"%s\" pointer=\"%s\" enum_count=\"%d\" description=\"%s\">\n", arg->name, gs_inout[arg->inout], gs_c_datatype[arg->datatype], gs_objecttype[arg->objecttype], arg->rowexp, arg->colexp, arg->sparse_attr.nnzexp, arg->sparse_attr.indices, arg->sparse_attr.pointer, enum_count, arg->description);
    s = dstring_append_free(s, stmp);

    if(enum_count > 0) {
      stmp = dstring_sprintf("    <arg_enum>\n");
      s = dstring_append_free(s, stmp);

      for(arg_enum=arg->arg_enum; arg_enum!=NULL; arg_enum=arg_enum->next) {
        stmp = dstring_sprintf("      <enum_val val=\"%s\"/>\n", arg_enum->val);
        s = dstring_append_free(s, stmp);
      }

      stmp = dstring_sprintf("    </arg_enum>\n");
      s = dstring_append_free(s, stmp);
    }

    stmp = dstring_sprintf("  </arg>\n");
    s = dstring_append_free(s, stmp);
  }

  stmp = dstring_sprintf(" </arglist>\n");
  s = dstring_append_free(s, stmp);
 
  if(gs_encode_infolist(&s, problem->infolist) <0)
    return -1;

  stmp = dstring_sprintf("</problem>");
  s = dstring_append_free(s, stmp);

  *problemstring = s;
  
  return 0;
}

int 
gs_decode_problem(char *problemstring, gs_problem_t *problem)
{
  int n, nchars, count, enum_count, idx, maxlen = strlen(problemstring)+1;
  char *strp = problemstring, *inout, *datatype, *objecttype, *ptype;
  gs_argument_t *arg, *ap;
 
  n = nchars = count = enum_count = idx = 0;

  problem->arglist = NULL;
  problem->next = NULL;
  problem->infolist = NULL;
  problem->work = NULL;
  problem->worksize = 0;

  ptype = CALLOC(maxlen, sizeof(char));

  problem->name = CALLOC(maxlen, sizeof(char));
  problem->description = CALLOC(maxlen, sizeof(char));
  problem->callsig = CALLOC(maxlen, sizeof(char));
  n = sscanf(strp, "<problem name=\"%[^\"]\" type=\"%[^\"]\" description=\"%[^\"]\" major=\"%d\" callsig=\"%[^\"]\">\n %n", problem->name, ptype, problem->description, &(problem->major), problem->callsig, &nchars);
  strp = strp+nchars;   /* move past processed chars */
  problem->name = REALLOC(problem->name, strlen(problem->name)+1);
  problem->description = REALLOC(problem->description, strlen(problem->description)+1);

  problem->type = gs_parse_probtype(ptype);
  free(ptype);
  if(problem->type == GS_BAD_PTYPE) {
    ERRPRINTF("bad problem type specified.\n");
    return -1;
  }

  n = sscanf(strp, " <arglist count=\"%d\">\n %n", &count, &nchars);
  strp = strp+nchars;   /* move past processed chars */
  
  inout = CALLOC(maxlen, sizeof(char));
  datatype = CALLOC(maxlen, sizeof(char));
  objecttype = CALLOC(maxlen, sizeof(char));

  for (nchars=0,idx=0; idx<count; idx++) {
    arg = (gs_argument_t*)CALLOC(1, sizeof(gs_argument_t));
    arg->data_handle = 0;
    arg->pass_back = 1;
    arg->next = NULL;
    arg->prob = problem;
    arg->name = CALLOC(maxlen, sizeof(char));
    arg->rowexp = CALLOC(maxlen, sizeof(char));
    arg->colexp = CALLOC(maxlen, sizeof(char));
    arg->sparse_attr.nnzexp = CALLOC(maxlen, sizeof(char));
    arg->sparse_attr.indices = CALLOC(maxlen, sizeof(char));
    arg->sparse_attr.pointer = CALLOC(maxlen, sizeof(char));
    arg->description = CALLOC(maxlen, sizeof(char));
    arg->arg_enum = NULL;

    n = sscanf(strp, "  <arg name=\"%[^\"]\" inout=\"%[^\"]\" datatype=\"%[^\"]\" objecttype=\"%[^\"]\" rowexp=\"%[^\"]\" colexp=\"%[^\"]\" nnzexp=\"%[^\"]\" indices=\"%[^\"]\" pointer=\"%[^\"]\" enum_count=\"%d\" description=\"%[^\"]\">\n %n", arg->name, inout, datatype, objecttype, arg->rowexp, arg->colexp, arg->sparse_attr.nnzexp, arg->sparse_attr.indices, arg->sparse_attr.pointer, &enum_count, arg->description, &nchars);
    strp = strp+nchars; /* move past processed chars */

    if(enum_count > 0) {
      gs_arg_enum_t *ap;
      char *enum_string;
      int i;

      enum_string = (char *)malloc(maxlen);
      if(!enum_string) {
        ERRPRINTF("malloc.\n");
        return -1;
      }

      n = sscanf(strp, "    <arg_enum>\n %n", &nchars);
      strp = strp+nchars;   /* move past processed chars */

      ap = (gs_arg_enum_t *) malloc(enum_count * sizeof(gs_arg_enum_t));
      if(!ap) {
        ERRPRINTF("malloc.\n");
        return -1;
      }

      /* i have allocated an array of gs_arg_enum_t, but i'm going to construct
       * it sort of like a linked list, linking ap[i].next to the address of
       * a[i+1].
       */

      for(i=0; i < enum_count; i++) {
        n = sscanf(strp, "      <enum_val val=\"%[^\"]\"/>\n %n", enum_string, &nchars);
        strp = strp+nchars; /* move past processed chars */

        ap[i].val = strdup(enum_string);
        if(!ap[i].val) {
          ERRPRINTF("malloc.\n");
          return -1;
        }
    
        ap[i].next = &ap[i+1];
      }

      ap[i-1].next = NULL;
      arg->arg_enum = ap;

      n = sscanf(strp, "    </arg_enum>\n %n", &nchars);
      strp = strp+nchars;   /* move past processed chars */

      free(enum_string);
    }

    n = sscanf(strp, " </arg>\n %n", &nchars);
    strp = strp+nchars; /* move past processed chars */

    arg->name = REALLOC(arg->name, strlen(arg->name)+1);
    
    arg->inout = gs_parse_inout(inout);
    if(arg->inout == GS_BAD_INOUT) {
      ERRPRINTF("bad in/out specified.\n");
      return -1;
    }

    arg->datatype = gs_parse_datatype(datatype);
    if(arg->datatype == GS_BAD_DTYPE) {
      ERRPRINTF("bad data type specified.\n");
      return -1;
    }

    arg->objecttype = gs_parse_objecttype(objecttype);
    if(arg->objecttype == GS_BAD_OTYPE) {
      ERRPRINTF("bad object type specified.\n");
      return -1;
    }

    arg->rowexp = REALLOC(arg->rowexp, strlen(arg->rowexp)+1);
    arg->colexp = REALLOC(arg->colexp, strlen(arg->colexp)+1);
    arg->sparse_attr.nnzexp = REALLOC(arg->sparse_attr.nnzexp, 
      strlen(arg->sparse_attr.nnzexp)+1);
    arg->sparse_attr.indices = REALLOC(arg->sparse_attr.indices, 
      strlen(arg->sparse_attr.indices)+1);
    arg->sparse_attr.pointer = REALLOC(arg->sparse_attr.pointer, 
      strlen(arg->sparse_attr.pointer)+1);
    arg->description = REALLOC(arg->description, strlen(arg->description)+1);
    if (problem->arglist == NULL) problem->arglist = arg;
    else {
      for (ap=problem->arglist; ap->next!=NULL; ap=ap->next) {}
      ap->next = arg;
    }
  }

  n = sscanf(strp, " </arglist>\n %n", &nchars);
  strp = strp+nchars;   /* move past processed chars */

  gs_decode_infolist(strp, &problem->infolist);

  n = sscanf(strp, " </problem>\n %n", &nchars);
  strp = strp+nchars;   /* move past processed chars */
  
  free(inout);
  free(datatype);
  free(objecttype);

  return 0;
}

int
gs_decode_dsi_object(char *encoding, DSI_OBJECT *obj)
{
  int nchars;
  char *tmp;

  if(!obj) return -1;

  tmp = (char *)malloc(strlen(encoding)+1);

  if(!tmp) return -1;

  obj->dsi_file = (DSI_FILE *)malloc(sizeof(DSI_FILE));

  if(!obj->dsi_file) {
    free(tmp);
    return -1;
  }

  if(sscanf(encoding, "<dsi_object> <flag> %d </flag>\n%n", 
       &(obj->dsi_file->flag), &nchars) != 1)
    goto scan_error;
  encoding += nchars;

  if(sscanf(encoding, "<perm> %d </perm>\n%n", 
       &(obj->dsi_file->perm), &nchars) != 1)
    goto scan_error;
  encoding += nchars;

  if(sscanf(encoding, "<uid> %d </uid>\n%n", 
       &(obj->dsi_file->uid), &nchars) != 1)
    goto scan_error;
  encoding += nchars;

  if(sscanf(encoding, "<written_count> %d </written_count>\n%n",
       &(obj->dsi_file->written_count), &nchars) != 1)
    goto scan_error;
  encoding += nchars;

  if(sscanf(encoding, "<offset> %d </offset>\n%n", 
       &(obj->offset), &nchars) != 1)
    goto scan_error;
  encoding += nchars;

  if(sscanf(encoding, "<storage_system> %d </storage_system>\n%n",
       &(obj->dsi_file->storage_system), &nchars) != 1)
    goto scan_error;
  encoding += nchars;

  if(obj->dsi_file->storage_system == GS_DSI_IBP) {
#ifdef DSI_IBP
    obj->dsi_file->dsi_specifics.ibp.depot = 
           (IBP_depot)malloc(sizeof(struct ibp_depot));

    if(!obj->dsi_file->dsi_specifics.ibp.depot) {
      free(tmp);
      if(obj->dsi_file) free(obj->dsi_file);
      return -1;
    }
      
    obj->dsi_file->dsi_specifics.ibp.cap = 
           (IBP_set_of_caps)malloc(sizeof(struct ibp_set_of_caps));

    if(!obj->dsi_file->dsi_specifics.ibp.cap) {
      free(tmp);
      if(obj->dsi_file) 
        free(obj->dsi_file);
      if(obj->dsi_file->dsi_specifics.ibp.depot)
        free(obj->dsi_file->dsi_specifics.ibp.depot);
      return -1;
    }
      
    if(sscanf(encoding, "<host> %s </host>\n%n", 
      obj->dsi_file->dsi_specifics.ibp.depot->host, &nchars) != 1)
      goto scan_error;
    encoding += nchars;

    if(sscanf(encoding, "<port> %d </port>\n%n",
      &(obj->dsi_file->dsi_specifics.ibp.depot->port), &nchars) != 1)
      goto scan_error;
    encoding += nchars;

    if(sscanf(encoding, "<readcap> %s </readcap>\n%n", tmp, &nchars) != 1)
      goto scan_error;
    obj->dsi_file->dsi_specifics.ibp.cap->readCap = strdup(tmp);
    encoding += nchars;

    if(sscanf(encoding, "<writecap> %s </writecap>\n%n", tmp, &nchars) != 1)
      goto scan_error;
    obj->dsi_file->dsi_specifics.ibp.cap->writeCap = strdup(tmp);
    encoding += nchars;

    if(sscanf(encoding, "<managecap> %s </managecap>\n%n", tmp, &nchars) != 1)
      goto scan_error;
    obj->dsi_file->dsi_specifics.ibp.cap->manageCap = strdup(tmp);
#endif
  }

  free(tmp);

  return 0;

scan_error:
  free(tmp);
  return -1;
}

int
gs_encode_dsi_object(char **msg, DSI_OBJECT *obj)
{
  char *tmp;

  *msg = dstring_sprintf("<dsi_object>\n");

  tmp = dstring_sprintf("  <flag> %d </flag>\n", obj->dsi_file->flag);
  *msg = dstring_append_free(*msg, tmp);
  tmp = dstring_sprintf("  <perm> %d </perm>\n", obj->dsi_file->perm);
  *msg = dstring_append_free(*msg, tmp);
  tmp = dstring_sprintf("  <uid> %d </uid>\n", obj->dsi_file->uid);
  *msg = dstring_append_free(*msg, tmp);
  tmp = dstring_sprintf("  <written_count> %d </written_count>\n", 
      obj->dsi_file->written_count);
  *msg = dstring_append_free(*msg, tmp);
  tmp = dstring_sprintf("  <offset> %d </offset>\n", obj->offset);
  *msg = dstring_append_free(*msg, tmp);
  tmp = dstring_sprintf("  <storage_system> %d </storage_system>\n", 
      obj->dsi_file->storage_system);
  *msg = dstring_append_free(*msg, tmp);

  if(obj->dsi_file->storage_system == GS_DSI_IBP) {
#ifdef DSI_IBP
    tmp = dstring_sprintf("  <host> %s </host>\n", 
       obj->dsi_file->dsi_specifics.ibp.depot->host);
    *msg = dstring_append_free(*msg, tmp);
    tmp = dstring_sprintf("  <port> %d </port>\n", 
       obj->dsi_file->dsi_specifics.ibp.depot->port);
    *msg = dstring_append_free(*msg, tmp);
    tmp = dstring_sprintf("  <readcap> %s </readcap>\n", 
       obj->dsi_file->dsi_specifics.ibp.cap->readCap);
    *msg = dstring_append_free(*msg, tmp);
    tmp = dstring_sprintf("  <writecap> %s </writecap>\n", 
       obj->dsi_file->dsi_specifics.ibp.cap->writeCap);
    *msg = dstring_append_free(*msg, tmp);
    tmp = dstring_sprintf("  <managecap> %s </managecap>\n", 
       obj->dsi_file->dsi_specifics.ibp.cap->manageCap);
    *msg = dstring_append_free(*msg, tmp);
#endif
  }

  tmp = dstring_sprintf("</dsi_object>\n");
  *msg = dstring_append_free(*msg, tmp);

  return 0;
}




#ifdef GS_SMART_GRIDSOLVE

int
gs_smart_encode_tg_rem_task_node(char **rem_task_node_str, gs_smart_tg_task_node * tg_task_node){
  gs_smart_tg_dep_link ** tg_node_frwrd_link;
  gs_smart_tg_dep_link ** tg_node_bkwrd_link;
  gs_smart_tg_obj_node * obj_node_ptr; 
  gs_smart_tg_remote_task_node * tg_rem_task_node;
  int i ;
  int nb_obj_frwd_links, nb_node_frwd_links, nb_node_bkwd_links;
  char *s = NULL;
  char *stmp = NULL;

  if((!tg_task_node) || (!tg_task_node->tg_rem_task_node)) return -1;  
  tg_rem_task_node=tg_task_node->tg_rem_task_node;

  s = dstring_sprintf("<begin_remote_task>");
  

  stmp = dstring_sprintf("<blocking=\"%d\">\n", tg_rem_task_node->blocking);
  s = dstring_append_free(s,stmp);
  stmp = dstring_sprintf("<nb_flops=\"%f\">\n", tg_rem_task_node->nb_flops);
  s = dstring_append_free(s,stmp);
  stmp = dstring_sprintf("<nb_servers=\"%d\">\n", tg_rem_task_node->nb_servers);
  s = dstring_append_free(s,stmp);
  
  stmp = dstring_sprintf("<nb_node_frwd_links=\"%d\">\n", 
                          tg_rem_task_node->nb_node_frwd_links);
  s = dstring_append_free(s,stmp);

  stmp = dstring_sprintf("<nb_node_bkwd_links=\"%d\">\n", 
                           tg_rem_task_node->nb_node_bkwd_links);
  s = dstring_append_free(s,stmp);
  
  nb_node_frwd_links=tg_rem_task_node->nb_node_frwd_links;
  nb_node_bkwd_links=tg_rem_task_node->nb_node_bkwd_links;

  if(((!tg_rem_task_node->tg_node_frwrd_link) &&  (nb_node_frwd_links>0)) || 
     ((!tg_rem_task_node->tg_node_bkwrd_link) &&  (nb_node_bkwd_links>0))){
     ERRPRINTF("SMART: Error remote task forward back links is NULL..\n");
     return -1;
   }
  
  tg_node_frwrd_link=tg_rem_task_node->tg_node_frwrd_link;
  tg_node_bkwrd_link=tg_rem_task_node->tg_node_bkwrd_link;

  
  for(i=0;i<nb_node_bkwd_links;i++){

    if(!tg_node_bkwrd_link[i]) return -1; 
    if(!tg_node_bkwrd_link[i]->obj_node_ptr) return -1;
    if(!tg_node_bkwrd_link[i]->obj_node_ptr->tg_obj_bkwrd_link) return -1;
    if(!tg_node_bkwrd_link[i]->obj_node_ptr->tg_obj_bkwrd_link->task_node_ptr) return -1;

    stmp = dstring_sprintf("<back_link_task_id=\"%d\" for_node_link_id=\"%d\" for_obj_link_id=\"%d\">\n", 
                           tg_node_bkwrd_link[i]->obj_node_ptr->tg_obj_bkwrd_link->task_node_ptr->id,
                           tg_node_bkwrd_link[i]->obj_node_ptr->tg_obj_bkwrd_link->for_link_pos,
                           tg_node_bkwrd_link[i]->for_link_pos);
    s = dstring_append_free(s,stmp);
  }

  for(i=0;i<nb_node_frwd_links;i++){
     if(!tg_node_frwrd_link[i]) return -1;
     if(!tg_node_frwrd_link[i]->obj_node_ptr) return -1;
     obj_node_ptr=tg_node_frwrd_link[i]->obj_node_ptr;

     stmp = dstring_sprintf("<in_call_seq_pos=\"%d\" out_call_seq_pos=\"%d\" data_ptr=\"%d\" byte_size=\"%d\" nb_obj_frwd_links=\"%d\">\n", 
                               obj_node_ptr->in_call_seq_pos,
                               obj_node_ptr->out_call_seq_pos,
                               obj_node_ptr->data_ptr,
                               obj_node_ptr->byte_size, 
                               obj_node_ptr->nb_obj_frwd_links);
     s = dstring_append_free(s,stmp);

     nb_obj_frwd_links=obj_node_ptr->nb_obj_frwd_links;

     stmp = dstring_sprintf("<name=%s\n>", obj_node_ptr->name);
     s = dstring_append_free(s,stmp);
  }

  stmp = dstring_sprintf("<end_remote_task>");
  s = dstring_append_free(s,stmp);
  *rem_task_node_str=s;
  return 0;
}





int
gs_smart_decode_tg_rem_task_node(char *rem_task_node_str, gs_smart_tg * task_graph,
                               gs_smart_tg_task_node * tg_task_node){
  
  gs_smart_tg_dep_link ** tg_node_frwrd_link;
  gs_smart_tg_obj_node * obj_node_ptr; 
  int n, nchars, i, j;
  int nb_node_frwd_links, nb_obj_frwd_links, nb_node_bkwd_links;
  int back_link_task_id, for_node_link_id, for_obj_link_id;
  char *strp = rem_task_node_str;
  gs_smart_tg_task_node * tg_src_task_node;
  gs_smart_tg_client_node * tg_src_clnt_node;
  gs_smart_tg_remote_task_node * tg_src_rem_task_node;
  gs_smart_tg_dep_link * for_task_link, * for_obj_link;
  gs_smart_tg_remote_task_node * tg_rem_task_node;
  gs_smart_tg_dep_link ** tg_obj_frwrd_link;
 
  if((!rem_task_node_str) || (!task_graph) || (!tg_task_node)) return -1;
  
  if(!tg_task_node->tg_rem_task_node) return -1;

  tg_rem_task_node=tg_task_node->tg_rem_task_node;


  n = sscanf(strp,"<begin_remote_task>%n", 
             &nchars);
  strp = strp+nchars;
  
  n = sscanf(strp, "<blocking=\"%d\">\n%n", 
             &tg_rem_task_node->blocking, &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<nb_flops=\"%lg\">\n%n", 
             &tg_rem_task_node->nb_flops, &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<nb_servers=\"%d\">\n%n",
              &tg_rem_task_node->nb_servers, &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<nb_node_frwd_links=\"%d\">\n%n", 
             &tg_rem_task_node->nb_node_frwd_links, &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<nb_node_bkwd_links=\"%d\">\n%n", 
              &tg_rem_task_node->nb_node_bkwd_links, &nchars);
  strp = strp+nchars;


  nb_node_frwd_links=tg_rem_task_node->nb_node_frwd_links;
  nb_node_bkwd_links=tg_rem_task_node->nb_node_bkwd_links;
  tg_rem_task_node->tg_node_bkwrd_link=(gs_smart_tg_dep_link **)
                    calloc(nb_node_bkwd_links, sizeof (gs_smart_tg_dep_link *));

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


  for(i=0; i<nb_node_bkwd_links; i++){
    n = sscanf(strp, 
               "<back_link_task_id=\"%d\" for_node_link_id=\"%d\" for_obj_link_id=\"%d\">\n%n", 
                           &back_link_task_id, &for_node_link_id, &for_obj_link_id, &nchars);
    strp = strp+nchars;
 
    if(!task_graph->task_nodes[back_link_task_id]) return -1; 
    tg_src_task_node=task_graph->task_nodes[back_link_task_id];
   
    if(tg_src_task_node->node_type==GS_SMART_TG_CLIENT_NODE){
      if(!tg_src_task_node->tg_client_node) return -1;
      tg_src_clnt_node=tg_src_task_node->tg_client_node;

      if(!tg_src_clnt_node->tg_node_frwrd_link[for_node_link_id]) return -1;
      for_task_link=tg_src_clnt_node->tg_node_frwrd_link[for_node_link_id];

      if(!for_task_link->obj_node_ptr) return -1;
      if(!for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id]) return -1;
      for_obj_link=for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id];

      tg_rem_task_node->tg_node_bkwrd_link[i]=for_obj_link;     
       tg_rem_task_node->tg_node_bkwrd_link[i]->back_link_pos=i;  
      for_obj_link->task_node_ptr=tg_task_node;
     }
     else if(tg_src_task_node->node_type==GS_SMART_TG_REM_TASK_NODE){
       if(!tg_src_task_node->tg_rem_task_node) return -1;
       tg_src_rem_task_node=tg_src_task_node->tg_rem_task_node;
       
       if(!tg_src_rem_task_node->tg_node_frwrd_link[for_node_link_id]) return -1;
       for_task_link=tg_src_rem_task_node->tg_node_frwrd_link[for_node_link_id];
  
       if(!for_task_link->obj_node_ptr) return -1;
       if(!for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id]) return -1;
       for_obj_link=for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id];
       tg_rem_task_node->tg_node_bkwrd_link[i]=for_obj_link;   
       tg_rem_task_node->tg_node_bkwrd_link[i]->back_link_pos=i;  
       for_obj_link->task_node_ptr=tg_task_node;
    }
  }


  tg_node_frwrd_link=(gs_smart_tg_dep_link **)
                     calloc(nb_node_frwd_links,sizeof(gs_smart_tg_dep_link *));

  if(!tg_node_frwrd_link) return -1;
  tg_rem_task_node->tg_node_frwrd_link= tg_node_frwrd_link;
  for(i=0; i<nb_node_frwd_links; i++){
    tg_node_frwrd_link[i]=(gs_smart_tg_dep_link *)
                           calloc(1, sizeof(gs_smart_tg_dep_link ));
    tg_node_frwrd_link[i]->task_node_ptr=tg_task_node;

    if(!tg_node_frwrd_link[i]) return -1;
    tg_node_frwrd_link[i]->for_link_pos=i;

    tg_node_frwrd_link[i]->obj_node_ptr=(gs_smart_tg_obj_node *)
                                         calloc(1,sizeof(gs_smart_tg_obj_node));

    if(!tg_node_frwrd_link[i]->obj_node_ptr) return -1;
    
    obj_node_ptr=tg_node_frwrd_link[i]->obj_node_ptr;
    obj_node_ptr->tg_obj_bkwrd_link=tg_node_frwrd_link[i];


    n = sscanf(strp, 
               "<in_call_seq_pos=\"%d\" out_call_seq_pos=\"%d\" data_ptr=\"%d\" byte_size=\"%d\" nb_obj_frwd_links=\"%d\">\n%n", 
               &obj_node_ptr->in_call_seq_pos, &obj_node_ptr->out_call_seq_pos, &obj_node_ptr->data_ptr, 
               &obj_node_ptr->byte_size, 
               &obj_node_ptr->nb_obj_frwd_links, &nchars);
    strp = strp+nchars;

    obj_node_ptr->name = (char *)calloc(strlen(rem_task_node_str)+1, sizeof(char));
    if(!obj_node_ptr->name) return -1;

    n = sscanf(strp, "<name=%s\n>%n", obj_node_ptr->name,  &nchars);
    strp = strp+nchars;
    obj_node_ptr->name = REALLOC(obj_node_ptr->name, strlen(obj_node_ptr->name)+1);

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



    nb_obj_frwd_links=obj_node_ptr->nb_obj_frwd_links;

    obj_node_ptr->tg_obj_frwrd_link=(gs_smart_tg_dep_link **)
                   calloc(nb_obj_frwd_links, sizeof(gs_smart_tg_dep_link *));


    tg_obj_frwrd_link =obj_node_ptr->tg_obj_frwrd_link;
    for(j=0;j<nb_obj_frwd_links;j++){
      tg_obj_frwrd_link[j]=(gs_smart_tg_dep_link *)
                   calloc(1, sizeof(gs_smart_tg_dep_link ));
      if(!tg_obj_frwrd_link[j]) return -1;

      tg_obj_frwrd_link[j]->for_link_pos=j;
      tg_obj_frwrd_link[j]->obj_node_ptr=obj_node_ptr;
    }
  }
  n = sscanf(strp, "<end_remote_task>%n", &nchars);
  strp = strp+nchars;
  return 0;
}

int
gs_smart_encode_tg_client_node(char **client_node_string,  gs_smart_tg_task_node * tg_task_node){
  gs_smart_tg_dep_link ** tg_node_frwrd_link;
  gs_smart_tg_dep_link ** tg_node_bkwrd_link;
  gs_smart_tg_obj_node * obj_node_ptr; 
  int i ;
  int nb_obj_frwd_links, nb_node_frwd_links, nb_node_bkwd_links;
  char *s = NULL;
  char *stmp = NULL;
  gs_smart_tg_client_node * tg_client_node;
  
  if(!tg_task_node) return -1;

  tg_client_node=tg_task_node->tg_client_node;

  if(!tg_client_node) return -1;

  s = dstring_sprintf("<begin_client_node>");

  stmp = dstring_sprintf("<nb_node_frwd_links=\"%d\">\n", 
                          tg_client_node->nb_node_frwd_links);
  s = dstring_append_free(s,stmp);

  stmp = dstring_sprintf("<nb_node_bkwd_links=\"%d\">\n", 
                           tg_client_node->nb_node_bkwd_links);
  s = dstring_append_free(s,stmp);


  nb_node_frwd_links=tg_client_node->nb_node_frwd_links;
  nb_node_bkwd_links=tg_client_node->nb_node_bkwd_links;

 
  if(((!tg_client_node->tg_node_frwrd_link) &&  (nb_node_frwd_links>0)) || 
     ((!tg_client_node->tg_node_bkwrd_link) &&  (nb_node_bkwd_links>0))){
     ERRPRINTF("SMART: Error client forward back links is NULL..\n");
     return -1;
   }

  tg_node_frwrd_link=tg_client_node->tg_node_frwrd_link;
  tg_node_bkwrd_link=tg_client_node->tg_node_bkwrd_link;

  for(i=0;i<nb_node_bkwd_links;i++){
    if(!tg_node_bkwrd_link[i]) return -1;
    if(!tg_node_bkwrd_link[i]->obj_node_ptr) return -1;
    obj_node_ptr=tg_node_bkwrd_link[i]->obj_node_ptr;
    if(!obj_node_ptr->tg_obj_bkwrd_link) return -1;
    
    if(!obj_node_ptr->tg_obj_bkwrd_link->task_node_ptr) return -1;

    stmp = dstring_sprintf("<back_link_task_id=\"%d\" for_node_link_id=\"%d\" for_obj_link_id=\"%d\">\n", 
                           obj_node_ptr->tg_obj_bkwrd_link->task_node_ptr->id,
                           obj_node_ptr->tg_obj_bkwrd_link->for_link_pos,
                           tg_node_bkwrd_link[i]->for_link_pos);
    s = dstring_append_free(s,stmp);
  }


  for(i=0;i<nb_node_frwd_links;i++){
    if(!tg_node_frwrd_link[i]) return -1;
    if(!tg_node_frwrd_link[i]->obj_node_ptr) return -1;
    stmp = dstring_sprintf("<in_call_seq_pos=\"%d\" out_call_seq_pos=\"%d\" data_ptr=\"%d\" byte_size=\"%d\" nb_obj_frwd_links=\"%d\">\n", 
                               tg_node_frwrd_link[i]->obj_node_ptr->in_call_seq_pos,
                               tg_node_frwrd_link[i]->obj_node_ptr->out_call_seq_pos,
                               tg_node_frwrd_link[i]->obj_node_ptr->data_ptr,
                               tg_node_frwrd_link[i]->obj_node_ptr->byte_size,
                               tg_node_frwrd_link[i]->obj_node_ptr->nb_obj_frwd_links);
    s = dstring_append_free(s,stmp);
 
     
    nb_obj_frwd_links=tg_node_frwrd_link[i]->obj_node_ptr->nb_obj_frwd_links;

    obj_node_ptr=tg_node_frwrd_link[i]->obj_node_ptr;

    if(!obj_node_ptr->name) return -1;
    
    stmp = dstring_sprintf("<name=%s\n>", obj_node_ptr->name);
    s = dstring_append_free(s,stmp);
  }

  stmp = dstring_sprintf("<end_client_node>");
  s = dstring_append_free(s,stmp);
  *client_node_string=s;

  return 0;

}



int
gs_smart_decode_tg_client_node(char *client_node_str, gs_smart_tg * task_graph,
                               gs_smart_tg_task_node * tg_task_node){

  gs_smart_tg_dep_link ** tg_node_frwrd_link;
  gs_smart_tg_obj_node * obj_node_ptr; 
  int n, nchars, i, j;
  int nb_node_frwd_links, nb_obj_frwd_links, nb_node_bkwd_links;
  int back_link_task_id, for_node_link_id, for_obj_link_id;
  char *strp = client_node_str;
  gs_smart_tg_task_node * tg_src_task_node;
  gs_smart_tg_client_node * tg_src_clnt_node;
  gs_smart_tg_remote_task_node * tg_src_rem_task_node;
  gs_smart_tg_dep_link * for_task_link, * for_obj_link;
  gs_smart_tg_dep_link ** bkwd_task_links;
  gs_smart_tg_dep_link ** tg_obj_frwrd_link;
  gs_smart_tg_client_node * tg_client_node;

  if((!client_node_str) || (!task_graph) || (!tg_task_node)) return -1;

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

  tg_client_node=tg_task_node->tg_client_node;
 
  n = sscanf(strp,"<begin_client_node>%n", 
             &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<nb_node_frwd_links=\"%d\">\n%n", 
             &tg_client_node->nb_node_frwd_links, &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<nb_node_bkwd_links=\"%d\">\n%n", 
              &tg_client_node->nb_node_bkwd_links, &nchars);
  strp = strp+nchars;

  nb_node_frwd_links=tg_client_node->nb_node_frwd_links;
  nb_node_bkwd_links=tg_client_node->nb_node_bkwd_links;


  /*
   * **********************************
   * Constructing backward links
   * **********************************
   */

  tg_client_node->tg_node_bkwrd_link=(gs_smart_tg_dep_link **)calloc(nb_node_bkwd_links, sizeof (gs_smart_tg_dep_link *));
  
  if(!tg_client_node->tg_node_bkwrd_link) return -1;

  bkwd_task_links=tg_client_node->tg_node_bkwrd_link;


  for(i=0; i<nb_node_bkwd_links; i++){
    bkwd_task_links[i] = (gs_smart_tg_dep_link *)calloc(1, sizeof(gs_smart_tg_dep_link));
    if(!bkwd_task_links[i]) return -1;
     bkwd_task_links[i]->back_link_pos=i;
   
    /*
     * Receiving information of which obj node this back link points back to..
     */   
    n = sscanf(strp, 
               "<back_link_task_id=\"%d\" for_node_link_id=\"%d\" for_obj_link_id=\"%d\">\n%n", 
                           &back_link_task_id, &for_node_link_id, &for_obj_link_id, &nchars);
    strp = strp+nchars;

    if(!task_graph->task_nodes[back_link_task_id]) return -1;
  
   /*
    * Source task node of obj node that this back link points back to..
    */
    
    tg_src_task_node=task_graph->task_nodes[back_link_task_id];

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

    bkwd_task_links=tg_client_node->tg_node_bkwrd_link;
    
    if(tg_src_task_node->node_type==GS_SMART_TG_CLIENT_NODE){

      if(!tg_src_task_node->tg_client_node) return -1;
 
      /*
       * Source client node of the obj node that this back link points back to..
       */
      tg_src_clnt_node=tg_src_task_node->tg_client_node;

      if(!tg_src_clnt_node->tg_node_frwrd_link[for_node_link_id]) return -1;

      /*
       * The forward task link that points to the obj node 
       * that this back link points back to..
       */

      for_task_link=tg_src_clnt_node->tg_node_frwrd_link[for_node_link_id];
     
      if(!for_task_link->obj_node_ptr) return -1;
      if(!for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id]) return -1;

      /*
       * The forward obj link that points from the obj node that this back link
       *  points back to.
       */
      for_obj_link=for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id];

      /*
       * This for object link points from the obj node to this task node
       */ 
      for_obj_link->task_node_ptr=tg_task_node;


      /* 
       * This forward object link points from the object node to this task node.
       * Therefore the twoway pointer of this forward object link is the 
       * exact same as the two way pointers of this backward object link.  
       */

      bkwd_task_links[i]=for_obj_link;    

     }
     else if(tg_src_task_node->node_type==GS_SMART_TG_REM_TASK_NODE){
      
       if(!tg_src_task_node->tg_rem_task_node) return -1;

      /*
       * Source remote node of the obj node that this back link points back to..
       */
       tg_src_rem_task_node=tg_src_task_node->tg_rem_task_node;

       if(!tg_src_rem_task_node->tg_node_frwrd_link[for_node_link_id]) return -1;
       /*
        * The forward task link that points to the obj node 
        * that this back link points back to..
        */  
       for_task_link=tg_src_rem_task_node->tg_node_frwrd_link[for_node_link_id];

       if(!for_task_link->obj_node_ptr) return -1;
       if(!for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id]) return -1;

      /*
       * The forward obj link that points from the obj node that this back link
       *  points back to.
       */
       for_obj_link=for_task_link->obj_node_ptr->tg_obj_frwrd_link[for_obj_link_id];
     

       /*
       * This for object link points from the obj node to this task node
       */ 
       for_obj_link->task_node_ptr=tg_task_node;


      /* 
       * This forward object link points from the object node to this task node.
       * Therefore the twoway pointer of this forward object link is the 
       * exact same as the two way pointers of this backward object link.  
       */
       bkwd_task_links[i]=for_obj_link;     
    }
  }


  /*
   * **********************************
   * Constructing forward links
   * **********************************
   */

  tg_node_frwrd_link=(gs_smart_tg_dep_link **)
                     calloc(nb_node_frwd_links,sizeof(gs_smart_tg_dep_link *));

  if(!tg_node_frwrd_link) return -1;

  tg_client_node->tg_node_frwrd_link= tg_node_frwrd_link;

  /*
   * Constructing forward node links
   */  
  for(i=0; i<nb_node_frwd_links; i++){
    tg_node_frwrd_link[i]=(gs_smart_tg_dep_link *)
                           calloc(1, sizeof(gs_smart_tg_dep_link ));


    tg_node_frwrd_link[i]->task_node_ptr=tg_task_node;
  /*
   * Allocating object node that this for obj link points to
   */ 
    if(!tg_node_frwrd_link[i]) return -1;
    tg_node_frwrd_link[i]->obj_node_ptr=(gs_smart_tg_obj_node *)
                                         calloc(1,sizeof(gs_smart_tg_obj_node));
    
    

    if(!tg_node_frwrd_link[i]->obj_node_ptr) return -1;
    obj_node_ptr=tg_node_frwrd_link[i]->obj_node_ptr;

    
    obj_node_ptr->tg_obj_bkwrd_link=tg_node_frwrd_link[i];

  /*
   * Receiving information on object node attributes
   */  
    n = sscanf(strp, 
               "<in_call_seq_pos=\"%d\" out_call_seq_pos=\"%d\" data_ptr=\"%d\" byte_size=\"%d\" nb_obj_frwd_links=\"%d\">\n%n", 
               &obj_node_ptr->in_call_seq_pos, &obj_node_ptr->out_call_seq_pos, &obj_node_ptr->data_ptr, &obj_node_ptr->byte_size, 
               &obj_node_ptr->nb_obj_frwd_links, &nchars);
    strp = strp+nchars;

    obj_node_ptr->name = (char *)calloc(strlen(client_node_str)+1, sizeof(char));
    if(!obj_node_ptr->name) return -1;

  /*
   * Receiving object node name.
   */  
    n = sscanf(strp, "<name=%s\n>%n", obj_node_ptr->name,  &nchars);
    strp = strp+nchars;
   
    obj_node_ptr->name = REALLOC(obj_node_ptr->name, strlen(obj_node_ptr->name)+1);
    if(!obj_node_ptr->name) return -1;

    
    nb_obj_frwd_links=obj_node_ptr->nb_obj_frwd_links;

    tg_obj_frwrd_link=(gs_smart_tg_dep_link **)
                   calloc(nb_obj_frwd_links, sizeof(gs_smart_tg_dep_link *));

    if(!tg_obj_frwrd_link) return -1;

    obj_node_ptr->tg_obj_frwrd_link=tg_obj_frwrd_link;
 
  /*
   * Constructing forward object  links which point from the object node
   * to a task node.
   */  

    for(j=0;j<nb_obj_frwd_links;j++){
      tg_obj_frwrd_link[j]=(gs_smart_tg_dep_link *)
                   calloc(1, sizeof(gs_smart_tg_dep_link ));

      if(!tg_obj_frwrd_link[j]) return -1;

      tg_obj_frwrd_link[j]->for_link_pos=j;
      tg_obj_frwrd_link[j]->obj_node_ptr=obj_node_ptr;
    }
  }

  n = sscanf(strp, "<end_client>%n", &nchars);
  strp = strp+nchars;
  return 0;
}



int
gs_smart_encode_app_pm(char **app_pm_str, gs_smart_app_pm * app_pm){
  int i, j ;
  char *s = NULL;
  char *stmp = NULL;
  if(!app_pm){
    ERRPRINTF("SMART: Error encoding app pm, app pm NULL\n");
    return -1;
  }

  s = dstring_sprintf("<number tasks=\"%d\" >\n", app_pm->nb_tasks);
  for(i=0; i<app_pm->nb_tasks;i++){
    stmp = dstring_sprintf("<task node id=\"%d\" local=\"%d\">", i, app_pm->tasks[i]->local);
    s = dstring_append_free(s,stmp);
    if(app_pm->tasks[i]->local==1){
      stmp = dstring_sprintf("<nb_args=\"%d\">", app_pm->tasks[i]->nb_args);
      s = dstring_append_free(s,stmp);
      for(j=0; j<app_pm->tasks[i]->nb_args; j++){
        stmp = dstring_sprintf("<id=\"%d\">", app_pm->tasks[i]->args[j]->id);
        s = dstring_append_free(s,stmp);
      }
    }else{
      stmp = dstring_sprintf("<nickname=%s\n>", app_pm->tasks[i]->nickname);
      s = dstring_append_free(s,stmp);
      stmp = dstring_sprintf("<blocking=%d>", app_pm->tasks[i]->blocking);
      s = dstring_append_free(s,stmp);
      stmp = dstring_sprintf("<nb_args=\"%d\">", app_pm->tasks[i]->nb_args);
      s = dstring_append_free(s,stmp);
      for(j=0; j<app_pm->tasks[i]->nb_args; j++){
        stmp = dstring_sprintf("<id=\"%d\" scalar=\"%d\" type=\"%d\">", app_pm->tasks[i]->args[j]->id, app_pm->tasks[i]->args[j]->scalar, app_pm->tasks[i]->args[j]->type);
        s = dstring_append_free(s,stmp);
        if(app_pm->tasks[i]->args[j]->type==GS_INT){
          stmp = dstring_sprintf("<uvalue=\"%d\">", app_pm->tasks[i]->args[j]->uvalue.i);
          s = dstring_append_free(s,stmp);
        }

      }
    }
  }
  *app_pm_str = s;
  return 0;
}






int
gs_smart_decode_app_pm(char *app_pm_str, gs_smart_app_pm * app_pm){
  int id, i, j;
  char *strp = app_pm_str;
  int n, nchars;
  if(!app_pm){
    ERRPRINTF("SMART: Error decode string for app pm is NULL\n");
    return -1;
  }

  n = sscanf(strp,"<number tasks=\"%d\" >\n %n", &app_pm->nb_tasks, &nchars);
  strp = strp+nchars;
  app_pm->tasks=(gs_smart_app_pm_task **)calloc(app_pm->nb_tasks ,sizeof(gs_smart_app_pm_task *));
  for(i=0; i<app_pm->nb_tasks; i++){
    app_pm->tasks[i] = (gs_smart_app_pm_task *)calloc(1 ,sizeof(gs_smart_app_pm_task));
    if(!app_pm->tasks[i]) return -1;
    app_pm->tasks[i]->t_anayl=(gs_smart_t_dep_anayl *)calloc(1, sizeof(gs_smart_t_dep_anayl));
    if(!app_pm->tasks[i]->t_anayl) return -1;
  }
  for(i=0; i<app_pm->nb_tasks;i++){
    n = sscanf(strp, "<task node id=\"%d\" local=\"%d\">%n", &id, &app_pm->tasks[i]->local,&nchars);
    strp = strp+nchars;
    if(app_pm->tasks[i]->local==1){
      n = sscanf(strp, "<nb_args=\"%d\">%n", &app_pm->tasks[i]->nb_args,&nchars);
      strp = strp+nchars;
      app_pm->tasks[i]->args =(gs_smart_app_pm_args **)calloc(app_pm->tasks[i]->nb_args ,sizeof(gs_smart_app_pm_args * ));
      if(!app_pm->tasks[i]->args){
        ERRPRINTF("SMART: Error allocating memory to args\n");
        return -1;
      }

      for(j=0;j<app_pm->tasks[i]->nb_args;j++){
        app_pm->tasks[i]->args[j] = (gs_smart_app_pm_args *)calloc(1 ,sizeof(gs_smart_app_pm_args));
        if(!app_pm->tasks[i]->args[j]){
          ERRPRINTF("SMART: Error allocating to arg %d\n", j);
          return -1;
        }
        
        app_pm->tasks[i]->args[j]->a_anayl=(gs_smart_a_dep_anayl *)calloc(1, sizeof(gs_smart_a_dep_anayl)); 
        if(!app_pm->tasks[i]->args[j]->a_anayl){
          ERRPRINTF("SMART: Error allocating to arg anayl %d\n", j);
          return -1;
        }

        n = sscanf(strp, "<id=\"%d\">%n", &app_pm->tasks[i]->args[j]->id,  &nchars);
        strp = strp+nchars;
      }
    }
    else{
      app_pm->tasks[i]->nickname = (char *)calloc(strlen(app_pm_str)+1, sizeof(char));
      n = sscanf(strp, "<nickname=%s\n>%n", app_pm->tasks[i]->nickname,  &nchars);
      strp = strp+nchars;
      n = sscanf(strp, "<blocking=%d>%n", &app_pm->tasks[i]->blocking,  &nchars);
      strp = strp+nchars;
      app_pm->tasks[i]->nickname = REALLOC(app_pm->tasks[i]->nickname, strlen(app_pm->tasks[i]->nickname)+1);
      if(!app_pm->tasks[i]->nickname){
        ERRPRINTF("SMART: XML info decode error. Failed to allocate memory\n");
        return -1;
      }
     
      if(!app_pm->tasks[i]->nickname){
        ERRPRINTF("SMART: Failed to decode app_pm\n");
        return -1;
      }
     
      n = sscanf(strp, "<nb_args=\"%d\">%n",&app_pm->tasks[i]->nb_args, &nchars);
      strp = strp+nchars;

      app_pm->tasks[i]->args =(gs_smart_app_pm_args **)calloc(app_pm->tasks[i]->nb_args ,sizeof(gs_smart_app_pm_args * ));
      if(!app_pm->tasks[i]->args){
        ERRPRINTF("SMART: Failed to allocate memory for args\n");
        return -1;
      }
      for(j=0; j<app_pm->tasks[i]->nb_args; j++){
        app_pm->tasks[i]->args[j] = (gs_smart_app_pm_args *)calloc(1 ,sizeof(gs_smart_app_pm_args));
        if(!app_pm->tasks[i]->args[j]){
          ERRPRINTF("SMART: Failed to allocate memory for arg %d\n", j);
          return -1;
        }

        
        app_pm->tasks[i]->args[j]->a_anayl=(gs_smart_a_dep_anayl *)calloc(1, sizeof(gs_smart_a_dep_anayl)); 
        if(!app_pm->tasks[i]->args[j]->a_anayl){
          ERRPRINTF("SMART: Error allocating to arg anayl %d\n", j);
          return -1;
        }

        n = sscanf(strp, "<id=\"%d\" scalar=\"%d\" type=\"%d\">%n",&app_pm->tasks[i]->args[j]->id, &app_pm->tasks[i]->args[j]->scalar, &app_pm->tasks[i]->args[j]->type, &nchars);
        strp = strp+nchars;
      
        if(app_pm->tasks[i]->args[j]->type==GS_INT){
          n = sscanf(strp, "<uvalue=\"%d\">%n", &app_pm->tasks[i]->args[j]->uvalue.i, &nchars);
          strp = strp+nchars;
        }
      }
    }
  }
  return 0;
}






int gs_smart_encode_arg_map_info(char **arg_map_info,  gs_argument_t * argptr){
  char *s = NULL;
  char *stmp = NULL;
  if(!argptr) return -1;
  s = dstring_sprintf("<begin_arg_map_info>\n");
  stmp = dstring_sprintf("<input_stored_remotely=\" %d \">\n", argptr->input_arg_stored);
  s = dstring_append_free(s,stmp);
  stmp = dstring_sprintf("<input_arg_received_remotely=\" %d \">\n", argptr->input_arg_received_remotely);
  s = dstring_append_free(s,stmp);
  stmp = dstring_sprintf("<input_arg_deleted=\" %d \">\n", argptr->input_arg_deleted);
  s = dstring_append_free(s,stmp);
  stmp = dstring_sprintf("<output_arg_sent_remotely=\" %d \">\n", argptr->output_arg_sent_remotely);
  s = dstring_append_free(s,stmp);
  stmp = dstring_sprintf("<output_arg_cached=\" %d \">\n", argptr->output_cached);
  s = dstring_append_free(s,stmp);
  if(argptr->output_arg_sent_remotely){
    stmp = dstring_sprintf("<output_nb_dest_servers=\" %d \">\n", argptr->output_nb_dest_servers);
    s = dstring_append_free(s,stmp);
  }
  
  *arg_map_info=s;

  return 0;
}


int gs_smart_decode_arg_map_info(char *smart_arg_info, gs_argument_t * argptr){
  int n, nchars;
  char *strp = smart_arg_info;
  if(!argptr) return -1;
  n = sscanf(strp, "<begin_arg_map_info>\n%n", &nchars);
  strp = strp+nchars;
  n = sscanf(strp, "<input_stored_remotely=\" %d \">\n%n", &argptr->input_arg_stored, &nchars);
  strp = strp+nchars;
  n = sscanf(strp, "<input_arg_received_remotely=\" %d \">\n%n", &argptr->input_arg_received_remotely, &nchars);
  strp = strp+nchars;
  n = sscanf(strp, "<input_arg_deleted=\" %d \">\n%n", &argptr->input_arg_deleted, &nchars);
  strp = strp+nchars;
  n = sscanf(strp, "<output_arg_sent_remotely=\" %d \">\n%n", &argptr->output_arg_sent_remotely, &nchars);
  strp = strp+nchars;
  n = sscanf(strp, "<output_arg_cached=\" %d \">\n%n", &argptr->output_cached, &nchars);
  strp = strp+nchars;
  if(argptr->output_arg_sent_remotely){
    n = sscanf(strp, "<output_nb_dest_servers=\" %d \">\n%n", &argptr->output_nb_dest_servers, &nchars);
    strp = strp+nchars;
  }
  return 0;
}






int
gs_smart_encode_ping_info(char **encoding, gs_server_t *server, gs_server_t **server_list, double *times, int count){

  char componentid_string[CID_LEN*2+1];
  char *stmp = NULL;
  int i;    
  gs_server_t **s = server_list;   /* just a shortcut name */
  *encoding = dstring_sprintf("<smart_info>\n");
  stmp = dstring_sprintf("<count> %d </count>\n", count);
  *encoding = dstring_append_free(*encoding , stmp);

  for(i=0;i<count;i++){
    if(!s[i]){
      return -1;
    }
    proxy_cid_to_str(componentid_string, s[i]->componentid);
    stmp = dstring_sprintf("<componentid> %s </componentid>  <time> %f </time> \n", componentid_string, times[i]);
    *encoding = dstring_append_free(*encoding, stmp);
  }
   stmp = dstring_sprintf("</smart_info>");
   *encoding = dstring_append_free(*encoding, stmp);
  return 0;
}



int
gs_smart_decode_ping_info(char *encoding, gs_server_pings_t ***pings, int *np)
{
  int i, n, count, maxlen, nchars;
  gs_server_pings_t **parr;
  char *strp, *cid_tmp;

  *np = 0;
  *pings = NULL;

  strp = encoding;
  maxlen = strlen(strp);

  cid_tmp = (char *)calloc(maxlen, sizeof(char));
  if(!cid_tmp) return -1;

   if(strcmp(strp, "<no_pings>")==0){
    return 0;
  }

  n = sscanf(strp, "<smart_info>\n %n", &nchars);
  strp = strp+nchars;

  n = sscanf(strp, "<count> %d </count>\n %n", &count, &nchars);
  strp = strp+nchars;

  parr = (gs_server_pings_t **) malloc(count * sizeof(gs_server_pings_t *));
  if(!parr) {
    free(cid_tmp);
    return -1;
  }

  for(i=0;i<count;i++) {
    parr[i] = (gs_server_pings_t *) malloc(sizeof(gs_server_pings_t));
    if(!parr[i]) {
      /* probably need to free parr[1 through i-1] too */
      free(parr);
      free(cid_tmp);
      return -1;
    }

    n = sscanf(strp, "<componentid> %s </componentid>  <time> %lg </time>\n %n",
          cid_tmp, &(parr[i]->comm_time), &nchars);
    strp = strp+nchars;
    proxy_str_to_cid(parr[i]->componentid, cid_tmp);
  }

  n = sscanf(strp, "</smart_info>\n %n", &nchars);
  strp = strp+nchars;

  *np = count;
  *pings = parr;

  return 0;
}





#endif