gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[GNUnet-SVN] r15518 - gnunet/src/transport


From: gnunet
Subject: [GNUnet-SVN] r15518 - gnunet/src/transport
Date: Fri, 10 Jun 2011 12:22:47 +0200

Author: wachs
Date: 2011-06-10 12:22:47 +0200 (Fri, 10 Jun 2011)
New Revision: 15518

Modified:
   gnunet/src/transport/perf_transport_ats.c
Log:
removing glpk output


Modified: gnunet/src/transport/perf_transport_ats.c
===================================================================
--- gnunet/src/transport/perf_transport_ats.c   2011-06-10 10:07:51 UTC (rev 
15517)
+++ gnunet/src/transport/perf_transport_ats.c   2011-06-10 10:22:47 UTC (rev 
15518)
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2010, 2011 Christian Grothoff (and other contributing authors)
+     (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
@@ -18,7 +18,7 @@
      Boston, MA 02111-1307, USA.
 */
 /**
- * @file testing/perf_transport_ats.c
+ * @file testing/per_transport_ats.c
  * @brief testcase for ats functionality
  */
 #include "platform.h"
@@ -48,202 +48,186 @@
 static struct GNUNET_TIME_Absolute end;
 
 
-static void 
-solve_mlp(int presolve)
+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));
+       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)
+void solve_lp(int presolve)
 {
-  int result, 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));
+       int result, 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)
+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++)
+       //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))
        {
-         printf("%i = %f \n", ind[c2], val[c2]);
+               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++;
        }
-      
-      c++;
-    }
-  //glp_set_mat_row(prob, start, length, ind, val);
+       //glp_set_mat_row(prob, start, length, ind, val);
 }
-#endif
 
 
-static void
-bench_simplex_optimization(char * file, int executions)
+
+void bench_simplex_optimization(char * file, int executions)
 {
-  
-  int c;
-  prob = glp_create_prob();
-  glp_read_lp(prob, NULL, file);
-  
-  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);
+
+       int c;
+       prob = glp_create_prob();
+       glp_read_lp(prob, NULL, file);
+
+       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)
+void bench_simplex_no_optimization(char * file, int executions)
 {
-  
-  int c;
-  prob = glp_create_prob();
-  glp_read_lp(prob, NULL, file);
-  
-  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);
-}
 
+       int c;
+       prob = glp_create_prob();
+       glp_read_lp(prob, NULL, file);
 
-static void
-bench_mlp_no_optimization(char * file, int executions)
+       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);
+}
+
+void bench_mlp_no_optimization(char * file, int executions)
 {
-  
-  int c;
-  prob = glp_create_prob();
-  glp_read_lp(prob, NULL, file);
-  
-  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);
+
+       int c;
+       prob = glp_create_prob();
+       glp_read_lp(prob, NULL, file);
+
+       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)
+void bench_mlp_with_optimization(char * file, int executions, int changes)
 {
-  int c;
-  prob = glp_create_prob();
-  glp_read_lp(prob, NULL, file);
-  
-  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);
+       int c;
+       prob = glp_create_prob();
+       glp_read_lp(prob, NULL, file);
+
+       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
-static void 
-modify_cr (int start, int length, int count)
+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++)
+       //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))
        {
-         printf("%i = %f ", ind[c2], val[c2]);
+               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");
        }
-      c++;
-      printf ("\n----\n");
-    }
-  //glp_set_mat_row(prob, start, length, ind, val);
+       //glp_set_mat_row(prob, start, length, ind, val);
 }
 #endif
 #endif
 
-
-int
-main (int argc, char *argv[])
+int main (int argc, char *argv[])
 {
   int ret = 0;
   GNUNET_log_setup ("perf-transport-ats",
@@ -253,50 +237,64 @@
                     "INFO",
 #endif
                     NULL);
-  
+
 #if !HAVE_LIBGLPK
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-             "GLPK not installed, exiting testcase\n");
-  return 0;
+       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "GLPK not installed, exiting 
testcase\n");
+       return 0;
 #else
-  
+#if 0
+#endif
+  int nullfd = OPEN ("/dev/null", O_RDWR | O_APPEND);
+  if (nullfd < 0)
+    return GNUNET_SYSERR;
+  /* set stdin/stdout to /dev/null */
+  //stdi
+  if (/*(dup2 (nullfd, 0) < 0) || */(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";
-  // char * file = "mlps/ats_mlp_p500_m2000.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);
-  
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-             "Simplex no optimization average: %llu\n", 
-             sim_no_opt_avg  / EXECS);
+
   // -> 400 addresses
-  GAUGER ("GLPK",
-         "GLPK simplex  no optimization", 
-         (sim_no_opt_avg  / EXECS) / 400, 
-         "ms/address");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-             "Simplex, no optimization, average per peer: %llu\n",
-             (sim_with_opt_avg / EXECS) / 400);
-  GAUGER ("GLPK",
-         "GLPK simplex with optimization",
-         (sim_with_opt_avg  / EXECS) / 400,
-         "ms/address");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "MLP no optimization average: %llu\n", 
-             (mlp_no_opt_avg  / EXECS) / 400);
-  GAUGER ("GLPK",
-         "GLPK MLP no optimization", 
-         (mlp_no_opt_avg  / EXECS) / 400,
-         "ms/address");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MLP optimization average: %llu\n", 
-             (mlp_with_opt_avg/ EXECS) / 400);
-  GAUGER ("GLPK",
-         "GLPK MLP with optimization", 
-         (mlp_with_opt_avg  / EXECS) / 400, "ms/address");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+      "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_ERROR,
+      "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_ERROR,
+      "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_ERROR,
+      "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");
+
 #endif
+  (void) CLOSE (nullfd);
   return ret;
 }
 
 /* end of per_transport_ats.c*/
+




reply via email to

[Prev in Thread] Current Thread [Next in Thread]