/*
     This file is part of GNUnet.
     (C) 2009 Christian Grothoff (and other contributing authors)

     GNUnet is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published
     by the Free Software Foundation; either version 3, or (at your
     option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with GNUnet; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
*/
/**
 * @file transport/perf_transport_ats.c
 * @brief testcase for ats functionality
 */
#include "platform.h"
#include "gnunet_time_lib.h"
#include "gauger.h"
#include <glpk.h>

#define VERBOSE GNUNET_EXTRA_LOGGING

#define EXECS 5

static int ret = 0;

static int executions = EXECS;
static uint64_t exec_time[EXECS];

static uint64_t sim_no_opt_avg;
static uint64_t sim_with_opt_avg;
static uint64_t mlp_no_opt_avg;
static uint64_t mlp_with_opt_avg;

static glp_prob *prob;

static struct GNUNET_TIME_Absolute start;
static struct GNUNET_TIME_Absolute end;

static void
solve_mlp (int presolve)
{
  int result, solution;
  glp_iocp opt_mlp;

  glp_init_iocp (&opt_mlp);
  opt_mlp.msg_lev = GLP_MSG_OFF;
  opt_mlp.presolve = GLP_OFF;

  result = glp_intopt (prob, &opt_mlp);
  solution = glp_mip_status (prob);
  GNUNET_assert ((solution == 5) && (result == 0));
}

static void
solve_lp (int presolve)
{
  int result;
  int solution;

  glp_smcp opt_lp;

  glp_init_smcp (&opt_lp);

  opt_lp.msg_lev = GLP_MSG_OFF;
  if (presolve == GNUNET_YES)
    opt_lp.presolve = GLP_ON;
  else
    opt_lp.presolve = GLP_OFF;

  result = glp_simplex (prob, &opt_lp);
  solution = glp_get_status (prob);
  GNUNET_assert ((solution == 5) && (result == 0));
}

#if 0
/* Modify quality constraint */
static void
modify_qm (int start, int length, int values_to_change)
{
  //int * ind = GNUNET_malloc (length * sizeof (int));
  //double *val = GNUNET_malloc (length * sizeof (double));
  int ind[1000];
  double val[1000];

  int res = 0;
  int c = start, c2 = 1;

  while (c <= (start + values_to_change))
  {
    res = glp_get_mat_row (prob, c, ind, val);

    printf ("%i %i \n", c, res);
    for (c2 = 0; c2 < res; c2++)
    {
      printf ("%i = %f \n", ind[c2], val[c2]);
    }
    c++;
  }
  //glp_set_mat_row(prob, start, length, ind, val);
}
#endif



static void
bench_simplex_optimization (char *file, int executions)
{
  int c;
  int res;

  prob = glp_create_prob ();
  res = glp_read_lp (prob, NULL, file);
  if (res != 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
    ret = 1;
    return;
  }

  solve_lp (GNUNET_YES);

  for (c = 0; c < executions; c++)
  {
    start = GNUNET_TIME_absolute_get ();
    solve_lp (GNUNET_NO);
    end = GNUNET_TIME_absolute_get ();

    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;

    sim_with_opt_avg += exec_time[c];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Simplex /w optimization iterations %i: %llu \n", c,
                exec_time[c]);
  }

  glp_delete_prob (prob);
}


static void
bench_simplex_no_optimization (char *file, int executions)
{
  int c;
  int res;

  prob = glp_create_prob ();
  res = glp_read_lp (prob, NULL, file);
  if (res != 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
    ret = 1;
    return;
  }

  for (c = 0; c < executions; c++)
  {
    start = GNUNET_TIME_absolute_get ();
    solve_lp (GNUNET_YES);
    end = GNUNET_TIME_absolute_get ();

    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;

    sim_no_opt_avg += exec_time[c];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Simplex iterations %i: %llu \n", c,
                exec_time[c]);
  }

  glp_delete_prob (prob);
}

static void
bench_mlp_no_optimization (char *file, int executions)
{
  int c;
  int res;

  prob = glp_create_prob ();
  res = glp_read_lp (prob, NULL, file);
  if (res != 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
    ret = 1;
    return;
  }
  for (c = 0; c < executions; c++)
  {
    start = GNUNET_TIME_absolute_get ();
    solve_lp (GNUNET_YES);
    solve_mlp (GNUNET_NO);
    end = GNUNET_TIME_absolute_get ();

    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;

    mlp_no_opt_avg += exec_time[c];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "MLP iterations no optimization %i: %llu \n", c, exec_time[c]);
  }

  glp_delete_prob (prob);
}


static void
bench_mlp_with_optimization (char *file, int executions, int changes)
{
  int c;
  int res;

  prob = glp_create_prob ();
  res = glp_read_lp (prob, NULL, file);
  if (res != 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Problem file `%s' not found\n", file);
    ret = 1;
    return;
  }

  solve_lp (GNUNET_YES);

  for (c = 0; c < executions; c++)
  {
    start = GNUNET_TIME_absolute_get ();
    //modify_qm(906, 0, 0);
    solve_lp (GNUNET_NO);
    solve_mlp (GNUNET_NO);
    end = GNUNET_TIME_absolute_get ();

    exec_time[c] = GNUNET_TIME_absolute_get_difference (start, end).rel_value;

    mlp_with_opt_avg += exec_time[c];
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "MLP /w optimization iterations %i: %llu \n", c, exec_time[c]);
  }

  glp_delete_prob (prob);
}

#if 0
void
modify_cr (int start, int length, int count)
{
  //int * ind = GNUNET_malloc (length * sizeof (int));
  //double *val = GNUNET_malloc (length * sizeof (double));
  int ind[500];
  double val[500];
  int res = 0;
  int c = start, c2 = 1;

  while (c <= (start + count))
  {
    res = glp_get_mat_row (prob, c, ind, val);

    printf ("row index: %i non-zero elements: %i \n", c, res);
    for (c2 = 1; c2 <= res; c2++)
    {
      printf ("%i = %f ", ind[c2], val[c2]);
    }
    c++;
    printf ("\n----\n");
  }
  //glp_set_mat_row(prob, start, length, ind, val);
}
#endif


int
main (int argc, char *argv[])
{

  GNUNET_log_setup ("perf-transport-ats",
#if VERBOSE
                    "DEBUG",
#else
                    "INFO",
#endif
                    NULL);
  int nullfd = OPEN ("/dev/null", O_RDWR | O_APPEND);

  if (nullfd < 0)
    return GNUNET_SYSERR;
  if (dup2 (nullfd, 1) < 0)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
    (void) CLOSE (nullfd);
    return GNUNET_SYSERR;
  }


  char *file = "ats_mlp_p100_m400.problem";

  bench_simplex_no_optimization (file, executions);
  bench_simplex_optimization (file, executions);
  bench_mlp_no_optimization (file, executions);
  bench_mlp_with_optimization (file, executions, 0);

  if (ret != 0)
    return ret;

  // -> 400 addresses
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Simplex, no optimization, average per address: %f\n",
              ((double) sim_no_opt_avg / EXECS) / 400);
  GAUGER ("TRANSPORT", "GLPK simplex  no optimization",
          ((double) sim_no_opt_avg / EXECS) / 400, "ms/address");

  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Simplex, with optimization, average per address: %f\n",
              ((double) sim_with_opt_avg / EXECS) / 400);
  GAUGER ("TRANSPORT",
          "GLPK simplex, 100 peers 400 addresses with optimization",
          ((double) sim_with_opt_avg / EXECS) / 400, "ms/address");

  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "MLP no optimization average per address: %f\n",
              ((double) mlp_no_opt_avg / EXECS) / 400);
  GAUGER ("TRANSPORT", "GLPK MLP 100 peers 400 addresses no optimization",
          ((double) mlp_no_opt_avg / EXECS) / 400, "ms/address");

  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "MLP optimization average per address: %f\n",
              ((double) mlp_with_opt_avg / EXECS) / 400);
  GAUGER ("TRANSPORT", "GLPK MLP 100 peers 400 addresses with optimization",
          ((double) mlp_with_opt_avg / EXECS) / 400, "ms/address");
  (void) CLOSE (nullfd);
  return ret;
}

/* end of perf_transport_ats.c*/