main.c

/* 
 * 
 * Copyright (c) Year(s), 2013, Luis M. S. Russo and Alexandre 
 * P. Francisco / KDBIO / INESC-ID, <qhv@kdbio.inesc-id.pt> 
 *  
 * Any published media that is related with to use of the distributed 
 * software, or derived software, must contain a reference to "Extending 
 * quick hypervolume. Luís M. S. Russo, Alexandre P. Francisco: 
 * J. Heuristics 22(3): 245-271 (2016)".
 *  
 * Permission to use, copy, modify, and/or distribute this software for 
 * any purpose with or without fee is hereby granted, provided that the 
 * above copyright notice and this permission notice appear in all 
 * copies. 
 *  
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 
 * PERFORMANCE OF THIS SOFTWARE. 
 * 
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#undef _GNU_SOURCE
#include <string.h>
#include <assert.h>

#include <time.h>
/* #include <sys/resource.h> */
#include <pthread.h>

#include "point.h"
#include "quickhvolume.h"
#include "splitter.h"
#include "subsets.h"
#include "unionFilter.h"
#include "naiverandom.h"
#include "HSO.h"
#include "inexclusion.h"
#include "tpool.h"

double max = 1.0;

void* console(void *threadid)
{
  char line[1024];
  taskData l;                
  jobData jd;                
  int i;

  i = 0;
  while(i < NPOINTS)
    {
      l.idx[i] = i;
      i++;
    }

  l.z = cZero;
  l.o = cOne;

  jd.n = 0;
  IECinit();
  
  while(scanf("%[^\n]\n", line) > 0) /* Simple getline */
    {
      if('#' == line[0])
        {
          if(jd.n > 0)
            {
              memset(jd.r, 0, NPOINTS*sizeof(double)); /* Initial result */
              l.n = jd.n;
              postJob(&jd, &l);
            }
          jd.n = 0;
        }
      else
        {
          parsePoint(line, &(jd.PS[jd.n]), max);
          jd.n++;
        }      
    }

  pthread_exit(NULL);
}

int
main(int argc, char** argv)
{
  int t;                        
  if(1 == argc)
    {
      fprintf(stderr, "usage: qhv <#threads> <#inputfile>\n");
      exit(0);
    }

  t = 4;

  if (argc > 1) sscanf(argv[1], "%d", &t);
  if (argc > 2) stdin = fopen(argv[2], "r");
  if (argc > 3) max = atof(argv[3]);

  printf("Copyright (c) Year(s), 2013, Luis M. S. Russo and Alexandre \n");
  printf("P. Francisco / KDBIO / INESC-ID, <qhv@kdbio.inesc-id.pt> \n");
  printf(" \n");
  printf("Any published media that is related with to use of the distributed \n");
  printf("software, or derived software, must contain a reference to \"Luís  \n");
  printf("M. S. Russo, Alexandre P. Francisco: Extending quick hypervolume.  \n");
  printf("J. Heuristics 22(3): 245-271 (2016).\" \n");
  printf("  \n");
  printf("Permission to use, copy, modify, and/or distribute this software for  \n");
  printf("any purpose with or without fee is hereby granted, provided that the  \n");
  printf("above copyright notice and this permission notice appear in all  \n");
  printf("copies.  \n");
  printf("  \n");
  printf("THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL  \n");
  printf("WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED  \n");
  printf("WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE  \n");
  printf("AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL  \n");
  printf("DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR  \n");
  printf("PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER  \n");
  printf("TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR  \n");
  printf("PERFORMANCE OF THIS SOFTWARE.  \n");
  
  /*
  struct timeval tv1, tv2;
  struct rusage ru_before, ru_after;
  */
  struct timespec ts_before, ts_after;

  /* getrusage (RUSAGE_SELF, &ru_before); */
  clock_gettime(CLOCK_MONOTONIC_RAW, &ts_before);

  launch(t, console, quickHVolumeS, openBox, closeBox, priority, jobCopy, taskCopy, merge, publish);

  /* getrusage (RUSAGE_SELF, &ru_after); */
  clock_gettime(CLOCK_MONOTONIC_RAW, &ts_after);

  /*
  tv1 = ru_before.ru_utime;
  tv2 = ru_after.ru_utime;
  printf("Time: %f (s)\n", tv2.tv_sec + tv2.tv_usec * 1e-6 - tv1.tv_sec - tv1.tv_usec * 1e-6);
  */
  if (argc > 2) fclose(stdin);

  printf("Time: %f (s)\n", ts_after.tv_sec + ts_after.tv_nsec * 1e-9 - ts_before.tv_sec - ts_before.tv_nsec * 1e-9);

  exit(0);
}

/* int main(int argc, char** argv) */
/* { */
/*   int n;                        /\**< Size of point list *\/ */
/*   int a;                        /\**< Amount of alloced memory *\/ */
/*   point* L;                     /\**< List of alloced points *\/ */
/*   point* T;                     /\**< Temporary pointer *\/ */
/*   size_t k;                     /\**< Size of alloced line *\/ */
/*   char* line; */
/*   int read; */
/*   double HV;                    /\**< The HyperVolume *\/ */

/*   struct timeval tv1, tv2; */
/*   struct rusage ru_before, ru_after; */

/*   double max = 1.0; */

/*   /\* stdin = fopen("../tests/spherical/8d/DTLZSphereShape.8d.front.240pts.10", "r"); *\/ */
/*   if (argc > 1) stdin = fopen(argv[1], "r"); */
/*   if (argc > 2) max = atof(argv[2]); */

/*   a = 0; */
/*   n = 0; */
/*   k = 0; */
/*   line = NULL; */
/*   L = NULL; */
/*   read = 0; */
/*   /\* resetHSO();                   /\\**< Initiate the HSO sub-calculator *\\/ *\/ */
/*   IECinit(); */
/*   initSplitter(); */
/*   /\* printf("N is %d\n", N); *\/ */

/*   do{ */
/*     read = getline(&line, &k, stdin); */
/*     if(read > 0) */
/*       { */
/*         switch(line[0]) */
/*           { */
/*           case '#': */
/*             if(n > 0) */
/*               { */
/*                 getrusage (RUSAGE_SELF, &ru_before); */

/*                 initUnion(n);                 /\**< TODO: update this *\/ */
/*                 HV = quickHVolume(n, L); */

/*                 printf("%1.10f\n", HV); */
        
/*                 getrusage (RUSAGE_SELF, &ru_after); */
/*              tv1 = ru_before.ru_utime; */
/*                 tv2 = ru_after.ru_utime; */
/*                 printf("Time: %f (s)\n", tv2.tv_sec + tv2.tv_usec * 1e-6 - tv1.tv_sec - tv1.tv_usec * 1e-6); */

/*               } */
/*             n = 0; */
/*             break; */
/*           default: */
/*             if(n == a) */
/*               { */
/*                 a++; */
/*                 a*=2; */
/*                 L = (point*) realloc(L, a*sizeof(point)); */
/*                 if(((int)L % 16) != 0) */
/*                   { */
/*                     posix_memalign((void**)&T, 16, a*sizeof(point)); */
/*                     memcpy(T, L, n*sizeof(point)); */
/*                     free(L); */
/*                     L = T; */
/*                   } */
/*               } */
            
/*             parsePoint(line, &L[n], max); */
/*             n++; */
/*             break; */
/*           } */
/*       } */
/*   }while(read > 0); */

/*   free(L); */
/*   free(line); */
/*   destroySplitter(); */

/*   /\* fclose(stdin); *\/ */
/*   if (argc > 1) fclose(stdin); */

/*   return 0; */
/* } */