problem_util.c

Go to the documentation of this file.

/* $Id: problem_util.c,v 1.67 2008/10/27 19:04:45 seymour Exp $ */
/* $UTK_Copyright: $ */


#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "portability.h"
#include "problem.h"
#include "comm_encode.h"
#include "utility.h"
#include "proxylib.h"

static int
  gs_free_problem_common(gs_problem_t *, int);

char *gs_inout[] = {
  "in",
  "inout",
  "out",
  "workspace",
  "varout",
  "bad inout"
};

char *gs_c_datatype[] = {
  "int",
  "float",
  "double",
  "gs_scomplex",
  "gs_dcomplex",
  "char",
  "bad data type"
};

char *gs_objecttype[] = {
  "scalar",
  "vector",
  "matrix",
  "sparsematrix",
  "file",
  "packedfile",
  "bad object type"
};

char *gs_probtype[] = {
  "subroutine",
  "function",
  "bad prob type"
};

char *gs_const[] = {
  "10",
  "5.0",
  "10.0",
  "__scval",
  "__dcval",
  "'n'",
  "bad const"
};

char *gs_service_error[] = {
  "Unused error code",                          /*   not defined in enum      */
  "No error",                                   /*   not defined in enum      */
  "Unused error code",                          /*   not defined in enum      */
  "malloc failed",                              /* GS_SVC_ERR_MALLOC          */
  "Error loading service XML file",             /* GS_SVC_ERR_MISSING_XML     */
  "Error loading server info XML file",         /* GS_SVC_ERR_MISSING_SV_XML  */
  "Error creating problem XML for request",     /* GS_SVC_ERR_CREATE_XML      */
  "Could not open data file obtain output",     /* GS_SVC_ERR_OPEN_DATA_FILE  */
  "Could not create data file to save output",  /* GS_SVC_ERR_CREAT_DATA_FILE */
  "Could not create completion file",           /* GS_SVC_ERR_COMPLETION_FILE */
  "Could not encode problem into XML",          /* GS_SVC_ERR_PROBLEM_ENC     */
  "Could not get current working directory",    /* GS_SVC_ERR_GETCWD          */
  "Error creating request id",                  /* GS_SVC_ERR_REQID           */
  "Could not create request subdirectory",      /* GS_SVC_ERR_MKDIR           */
  "Could not chdir to request subdirectory",    /* GS_SVC_ERR_CHDIR           */
  "Failed to set up signal handler",            /* GS_SVC_ERR_SIGNALS         */
  "Failed to fork service process",             /* GS_SVC_ERR_FORK            */
  "Failed to wait for service process",         /* GS_SVC_ERR_WAITPID         */
  "Service process did not terminate properly", /* GS_SVC_ERR_ABNORMAL_EXIT   */
  "I/O Error transferring args",                /* GS_SVC_ERR_IO              */
  "Error executing service (likely missing)",   /* GS_SVC_ERR_EXEC            */
  "Error reading problem file from disk",       /* GS_SVC_ERR_READ_PROBLEM    */
  "Error restoring arg structures from disk",   /* GS_SVC_ERR_RESTORE_ARGS    */
  "Specified request ID not found on server",   /* GS_SVC_ERR_UNKNOWN_REQ     */
  "Request subdirectory removed while waiting", /* GS_SVC_ERR_REQ_DIR_GONE    */
  "Request not finished yet",                   /* GS_SVC_ERR_NOT_FINISHED    */
  "Invalid request ID (can't parse pid)",       /* GS_SVC_ERR_INVALID_PID     */
  "Could not kill service process",             /* GS_SVC_ERR_CANT_KILL       */
  "Invalid blocking/nonblocking specifier tag", /* GS_SVC_ERR_BAD_NB_TAG      */
  "Server has too many jobs running now",       /* GS_SVC_ERR_RESTRICT_JOBS   */
  "Only accepts jobs during a restricted time", /* GS_SVC_ERR_RESTRICT_TIME   */
  "Unsupported batch mode",                     /* GS_SVC_ERR_BAD_BATCH_MODE  */
  "Could not obtain lock on file",              /* GS_SVC_ERR_FILE_LOCK       */
  "Could not release lock on file",             /* GS_SVC_ERR_FILE_UNLOCK     */
  "Unspecified server error"                    /* GS_SVC_ERR_UNSPECIFIED     */
};

enum inout
gs_parse_inout(const char *str)
{
  if(!str)
    return GS_BAD_INOUT;

  if(!strcasecmp(str, gs_inout[GS_IN]))
    return GS_IN;
  if(!strcasecmp(str, gs_inout[GS_INOUT]))
    return GS_INOUT;
  if(!strcasecmp(str, gs_inout[GS_OUT]))
    return GS_OUT;
  if(!strcasecmp(str, gs_inout[GS_VAROUT]))
    return GS_VAROUT;
  if(!strcasecmp(str, gs_inout[GS_WORKSPACE]))
    return GS_WORKSPACE;

  return GS_BAD_INOUT;
}

enum datatype
gs_parse_datatype(const char *str)
{
  if(!str)
    return GS_BAD_DTYPE;

  if(!strcasecmp(str, gs_c_datatype[GS_INT]))
    return GS_INT;
  if(!strcasecmp(str, gs_c_datatype[GS_FLOAT]))
    return GS_FLOAT;
  if(!strcasecmp(str, gs_c_datatype[GS_DOUBLE]))
    return GS_DOUBLE;
  if(!strcasecmp(str, gs_c_datatype[GS_SCOMPLEX]))
    return GS_SCOMPLEX;
  if(!strcasecmp(str, gs_c_datatype[GS_DCOMPLEX]))
    return GS_DCOMPLEX;
  if(!strcasecmp(str, gs_c_datatype[GS_CHAR]))
    return GS_CHAR;

  return GS_BAD_DTYPE;
}

enum objecttype
gs_parse_objecttype(const char *str)
{
  if(!str)
    return GS_BAD_OTYPE;

  if(!strcasecmp(str, gs_objecttype[GS_SCALAR]))
    return GS_SCALAR;
  if(!strcasecmp(str, gs_objecttype[GS_VECTOR]))
    return GS_VECTOR;
  if(!strcasecmp(str, gs_objecttype[GS_MATRIX]))
    return GS_MATRIX;
  if(!strcasecmp(str, gs_objecttype[GS_SPARSEMATRIX]))
    return GS_SPARSEMATRIX;
  if(!strcasecmp(str, gs_objecttype[GS_FILE]))
    return GS_FILE;
  if(!strcasecmp(str, gs_objecttype[GS_PACKEDFILE]))
    return GS_PACKEDFILE;

  return GS_BAD_OTYPE;
}

enum probtype
gs_parse_probtype(const char *str)
{
  if(!str)
    return GS_BAD_PTYPE;

  if(!strcasecmp(str, gs_probtype[GS_SUBROUTINE]))
    return GS_SUBROUTINE;
  if(!strcasecmp(str, gs_probtype[GS_FUNCTION]))
    return GS_FUNCTION;

  return GS_BAD_PTYPE;
}

char *
gs_problem_getinfo(gs_problem_t * problem, char *type, char *defaultvalue)
{
  gs_info_t *info;

  if(!problem || !type)
    return NULL;

  for(info = problem->infolist; info != NULL; info = info->next)
    if(!strcmp(info->type, type))
      return info->value;

  return defaultvalue;
}

void
gs_infolist_dump(gs_info_t * infolist)
{
  gs_info_t *p;

  if(!infolist)
    return;

  printf("Problem attributes:\n");
  for(p = infolist; p != NULL; p = p->next)
    printf("  %s: %s\n", p->type, p->value);
}

void
gs_arg_dump(gs_argument_t * arg)
{
  if(!arg) {
    printf("NULL arg\n");
    return;
  }

  printf("  Argument Name:     %s\n", arg->name);
  printf("  Description:       %s\n", arg->description);
  printf("  In/out mode:       %s\n", gs_inout[arg->inout]);
  printf("  Data type:         %s\n", gs_c_datatype[arg->datatype]);
  printf("  Object type:       %s\n", gs_objecttype[arg->objecttype]);
  printf("  Row size expr:     %s\n", arg->rowexp);
  printf("  Column size expr:  %s\n", arg->colexp);
}

void
gs_arglist_dump(gs_argument_t * arglist)
{
  gs_argument_t *p;
  int i=0;

  for(p = arglist; p != NULL; p = p->next) {
    printf("Argument %d:\n", i++);
    gs_arg_dump(p);
    printf("\n");
  }
}

void
gs_problem_dump(gs_problem_t * problem)
{
  if(!problem) {
    printf("NULL problem\n");
    return;
  }

  printf("\n");
  printf("Problem Name: %s\n", problem->name);
  printf("\n");
  printf("Problem Description:\n  %s\n", problem->description);
  printf("\n");
  gs_arglist_dump(problem->arglist);
  gs_infolist_dump(problem->infolist);
}

void
gs_problemlist_dump(gs_problem_t * problem)
{
  gs_problem_t *p;

  printf("<problemlist>\n");
  for(p = problem; p != NULL; p = p->next)
    gs_problem_dump(p);
  printf("</problemlist>\n");
}

char *
gs_problem_prototype(gs_problem_t * problem)
{
  char *s, *stmp = NULL;
  gs_argument_t *arg = NULL;

  if(!problem) return NULL;

  s = strdup("");
  for(arg = problem->arglist; arg != NULL; arg = arg->next) {
    stmp = dstring_sprintf("inout=\"%s\" datatype=\"%s\" \
      objecttype=\"%s\" rowexp=\"%s\" colexp=\"%s\" \n",
      gs_inout[arg->inout], gs_c_datatype[arg->datatype],
      gs_objecttype[arg->objecttype], arg->rowexp, arg->colexp);
    s = dstring_append_free(s, stmp);
  }

  return s;
}

int
gs_dup_problem(gs_problem_t * dest, gs_problem_t * src)
{
  gs_argument_t *src_arg, *dest_arg;
  char *msg = NULL;

  if(!dest || !src)
    return -1;

  /* first copy most of the stuff the easy way - just encode the src and
     decode to the dest.  this won't copy everything however. */

  if(gs_encode_problem(&msg, src) < 0)
    return -1;

  if(gs_decode_problem(msg, dest) < 0) {
    if(msg)
      free(msg);
    return -1;
  }

  free(msg);

  /* now copy the remaining relevant information not contained in the
     encoding. */

  src_arg = src->arglist;
  dest_arg = dest->arglist;

  while(src_arg) {
    dest_arg->rows = src_arg->rows;
    dest_arg->cols = src_arg->cols;
    dest_arg->data = src_arg->data;

    src_arg = src_arg->next;
    dest_arg = dest_arg->next;
  }

  dest->major = src->major;
  dest->work = NULL;
  dest->worksize = 0;

  return 0;
}

int
gs_create_request_id(char *template)
{
  static char alphabet[] =
      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  char *p;
  unsigned int seed;

  if(!template)
    return -1;

#ifdef WIN32
  seed = (unsigned)time(NULL);
#else
  {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    seed = tv.tv_usec;
  }
#endif
  srand(seed);

  p = template;

  while(*p) {
    if(*p == 'X')
      *p = alphabet[rand() % 62];
    p++;
  }

  return 0;
}

int
gs_read_problem_from_file(char *fname, gs_problem_t * problem)
{
  char *problemstring = NULL;

  if(!fname || !problem)
    return -1;

  if(gs_get_contents_of_file(fname, &problemstring) < 0)
    return -1;

  /* parse buffer into problem structure */
  if(gs_decode_problem(problemstring, problem) < 0) {
    free(problemstring);
    return -1;
  }

  free(problemstring);

  return 0;
}

int
gs_read_server_from_file(char *fname, gs_server_t * server)
{
  char *serverstring = NULL;

  if(!fname || !server)
    return -1;

  if(gs_get_contents_of_file(fname, &serverstring) < 0)
    return -1;

  /* parse buffer into server structure */
  if(gs_decode_server(serverstring, server) < 0) {
    free(serverstring);
    return -1;
  }

  free(serverstring);

  return 0;
}

int
gs_free_problem(gs_problem_t *problem)
{
  return gs_free_problem_common(problem, FALSE);
}

int
gs_free_problem_and_data(gs_problem_t *problem)
{
  return gs_free_problem_common(problem, TRUE);
}

static int
gs_free_problem_common(gs_problem_t *problem, int free_data)
{
  gs_problem_t *tmpp, *prev;

  if(!problem)
    return -1;

  tmpp = problem;
  while(tmpp) {
    if(tmpp->name)
      free(tmpp->name);
    if(tmpp->description)
      free(tmpp->description);
    if(tmpp->callsig)
      free(tmpp->callsig);
    if(tmpp->work)
      free(tmpp->work);

    gs_free_arglist(tmpp->arglist, free_data);
    gs_free_infolist(tmpp->infolist);
    prev = tmpp;
    tmpp = tmpp->next;
    free(prev);
  }
  return 0;
}

int
gs_free_enumlist(gs_arg_enum_t *elist)
{
  gs_arg_enum_t *tmpe;

  if(!elist)
    return -1;

  tmpe = elist;
  while(tmpe) {
    if(tmpe->val)
      free(tmpe->val);
    tmpe = tmpe->next;
  }

  /* the enum list is built a bit differently, so we don't need
   * to free each element, just the head.
   */

  free(elist);

  return 0;
}

int
gs_free_arglist(gs_argument_t * arg, int free_data)
{
  gs_argument_t *tmpa, *prev;

  if(!arg)
    return -1;

  tmpa = arg;
  while(tmpa) {
    if(tmpa->name)
      free(tmpa->name);
    if(tmpa->description)
      free(tmpa->description);
    if(tmpa->rowexp)
      free(tmpa->rowexp);
    if(tmpa->colexp)
      free(tmpa->colexp);
    if(tmpa->sparse_attr.nnzexp)
      free(tmpa->sparse_attr.nnzexp);
    if(tmpa->sparse_attr.indices)
      free(tmpa->sparse_attr.indices);
    if(tmpa->sparse_attr.pointer)
      free(tmpa->sparse_attr.pointer);

    if(free_data && tmpa->data)
      free(tmpa->data);

    gs_free_enumlist(tmpa->arg_enum);

    prev = tmpa;
    tmpa = tmpa->next;
    free(prev);
  }

  return 0;
}


#ifdef GS_SMART_GRIDSOLVE

int
gs_smart_free_arg(gs_argument_t * arg, int free_data)
{
  int i;
  if(!arg)
    return -1;

  if(arg->name)
    free(arg->name);
  if(arg->description)
    free(arg->description);
  if(arg->rowexp)
    free(arg->rowexp);
  if(arg->colexp)
    free(arg->colexp);
  if(arg->sparse_attr.nnzexp)
    free(arg->sparse_attr.nnzexp);
  if(arg->sparse_attr.indices)
    free(arg->sparse_attr.indices);
  if(arg->sparse_attr.pointer)
    free(arg->sparse_attr.pointer);
  if(arg->input_arg_file)
    free(arg->input_arg_file);
  if(arg->output_arg_file)
    free(arg->output_arg_file);
     
  for(i=0;i<arg->input_nb_dest_servers;i++){
    if(arg->enc_input_dest_servers[i])
      free(arg->enc_input_dest_servers[i]);
  }
  if(arg->enc_input_dest_servers)
    free(arg->enc_input_dest_servers);

  for(i=0;i<arg->output_nb_dest_servers;i++){
    if(arg->enc_output_dest_servers[i])
      free(arg->enc_output_dest_servers[i]);
  }
  if(arg->enc_output_dest_servers)
    free(arg->enc_output_dest_servers);

  if(free_data && arg->data)
    free(arg->data);

  gs_free_enumlist(arg->arg_enum);

  free(arg);

  return 0;
}

#endif



int
gs_free_infolist(gs_info_t * info)
{
  gs_info_t *tmpi, *prev;

  if(!info)
    return -1;

  tmpi = info;
  while(tmpi) {
    if(tmpi->type)
      free(tmpi->type);
    if(tmpi->value)
      free(tmpi->value);
    prev = tmpi;
    tmpi = tmpi->next;
    free(prev);
  }

  return 0;
}

int
gs_create_error_file(char *req, int err)
{
  char *filename;
  FILE *error_file;

  if(!req) return -1;

  /* allocate enough for reqid + "/error" */
  filename = malloc(strlen(req) + 7);

  if(!filename)
    return -1;

  sprintf(filename, "%s/error", req);

  error_file = fopen(filename, "w");

  free(filename);

  if(error_file) {
    fprintf(error_file, "%d\n", err);
    fclose(error_file);
  }
  else
    return -1;

  return 0;
}

int
gs_create_timestamp_file(char *req, char *fname, double run_time)
{
  char *filename;
  FILE *timestamp_file;

  if(!req || !fname)
    return -1;

  filename = malloc(strlen(req) + strlen(fname) + 2);

  if(!filename)
    return -1;

  sprintf(filename, "%s/%s", req, fname);

  timestamp_file = fopen(filename, "w");

  free(filename);

  if(timestamp_file) {
    char timestr[100];
    struct tm *ptr;
    time_t tm;

    tm = time(NULL);
    ptr = localtime(&tm);
    strftime(timestr, 100, "%a %b %d %H:%M:%S %Z %Y", ptr);

    fprintf(timestamp_file, "%s\n", timestr);
    fprintf(timestamp_file, "%lf\n", run_time);

    fclose(timestamp_file);
  }
  else
    return -1;

  return 0;
}


int
gs_gen_sparse_mat_common(int datatype, size_t el_size, int m, int rmin, int rmax,
  void **a, int **ip, int **p)
{
  int i, ii, j, idx, nnz, *ptr, *ind;
  void *mat;

  nnz = 0;

  ptr = (int *) malloc((m+1) * sizeof(int));
  if(!ptr) return -1;

  ptr[0] = 0;
  for(i=1;i<=m;i++) {
    int colsize = random() % (rmax-rmin+1) + rmin;

    ptr[i] = ptr[i-1] + colsize;

    nnz += colsize;
  }

  ind = (int *)malloc(nnz * sizeof(int));
  if(!ind) return -1;
  mat = (void *) malloc(sizeof(double) * nnz * el_size);
  if(!mat) return -1;

  ii = idx = 0;
  for(i=0;i<m;i++) {
    int up, lo, remain, l = ptr[i+1]-ptr[i];

    remain = l;
    lo = -1;

    for(j=0;j<l;j++) {
      up = m - remain;
      lo = lo + 1;

      switch(datatype) {
        case GS_DOUBLE:
          ((double *)mat)[ii] = drand48();
          break;
        case GS_FLOAT:
          ((float *)mat)[ii] = (float)drand48();
          break;
        case GS_INT:
          ((int *)mat)[ii] = random();
          break;
        case GS_CHAR:
          ((int *)mat)[ii] = (random() % 26) + 'a';
          break;
        default:
          ERRPRINTF("Bad data type\n");
      }

      if(up != 0) {
        idx = random() % (up-lo) + lo;

        remain--;
      }
      else
        idx = lo;

      ind[ii] = idx;
      lo = idx;
      ii++;
    }
  }

  *p = ptr;
  *ip = ind;
  *a = mat;
  return nnz;
}

int
gs_gen_sparse_mat_double(int m, int rmin, int rmax,
  double **a, int **ip, int **p)
{
  return gs_gen_sparse_mat_common(GS_DOUBLE, sizeof(double), m, rmin, rmax,
    (void *)a, ip, p);
}

int
gs_gen_sparse_mat_float(int m, int rmin, int rmax,
  float **a, int **ip, int **p)
{
  return gs_gen_sparse_mat_common(GS_FLOAT, sizeof(float), m, rmin, rmax,
    (void *)a, ip, p);
}

int
gs_gen_sparse_mat_int(int m, int rmin, int rmax,
  int **a, int **ip, int **p)
{
  return gs_gen_sparse_mat_common(GS_INT, sizeof(int), m, rmin, rmax,
    (void *)a, ip, p);
}

int
gs_gen_sparse_mat_char(int m, int rmin, int rmax,
  char **a, int **ip, int **p)
{
  return gs_gen_sparse_mat_common(GS_CHAR, sizeof(char), m, rmin, rmax,
    (void *)a, ip, p);
}

gs_sparse_dup_t *
gs_dup_sparse_mat(int nnz, int dim, size_t el_size,
  void *m, int *ind, int *ptr)
{
  gs_sparse_dup_t *new_sp;

  new_sp = (gs_sparse_dup_t *) malloc(sizeof(gs_sparse_dup_t));

  if(!new_sp) return NULL;

  new_sp->m = (void *)malloc(sizeof(double) * el_size * nnz);
  new_sp->ind = (int *)malloc(nnz * sizeof(int));
  new_sp->ptr = (int *)malloc(dim * sizeof(int));

  if(!new_sp->m || !new_sp->ind || !new_sp->ptr) {
    if(new_sp->m) free(new_sp->m);
    if(new_sp->ind) free(new_sp->ind);
    if(new_sp->ptr) free(new_sp->ptr);
    if(new_sp) free(new_sp);
    ERRPRINTF("malloc failed.\n");
    return NULL;
  }

  memcpy(new_sp->m, m, nnz * el_size);
  memcpy(new_sp->ind, ind, nnz * sizeof(int));
  memcpy(new_sp->ptr, ptr, dim * sizeof(int));

  return new_sp;
}

gs_argument_t *
gs_arg_lookup_by_name(char *name, gs_argument_t *arglist) 
{
  gs_argument_t *arg;
  for (arg = arglist; arg != NULL; arg = arg->next) 
    if (!strcmp(name, arg->name) )
      return(arg);
  return NULL;
}


int
gs_arg_is_sparse_attr(char *name, gs_argument_t *arglist)
{
  gs_argument_t *arg;

  for(arg = arglist; arg != NULL; arg = arg->next) {
    if(arg->objecttype == GS_SPARSEMATRIX) {
      if(!strcmp(name, arg->sparse_attr.nnzexp) ||
         !strcmp(name, arg->sparse_attr.indices) ||
         !strcmp(name, arg->sparse_attr.pointer))
        return TRUE;
    }
  }

  return FALSE;
}



int gs_datatype_sizeof(int datatype) 
{
  switch(datatype) {
  case GS_INT:
    return sizeof(int);
    break;
  case GS_FLOAT:
    return sizeof(float);
    break;
  case GS_DOUBLE:
    return sizeof(double);
    break;
  case GS_SCOMPLEX:
    return sizeof(gs_scomplex);
    break;
  case GS_DCOMPLEX:
    return sizeof(gs_dcomplex);
    break;
  case GS_CHAR:
    return sizeof(char);
    break;
  default:
    return -1;
    break;
  }
}