fix 2688: profiler now uses GNUNET_TESTBED_run ()

git-svn-id: https://gnunet.org/svn/gnunet@25861 140774ce-b5e7-0310-ab8b-a85725594a96

2 files changed, 74 insertions, 666 deletions

diff --git a/src/testbed/gnunet-testbed-profiler.c b/src/testbed/gnunet-testbed-profiler.c
index 66170c1a71..f5b9b25667 100644
--- a/src/testbed/gnunet-testbed-profiler.c
+++ b/src/testbed/gnunet-testbed-profiler.c
@@ -38,126 +38,16 @@
 
 
 /**
- * DLL of operations
- */
-struct DLLOperation
-{
-  /**
-   * The testbed operation handle
-   */
-  struct GNUNET_TESTBED_Operation *op;
-
-  /**
-   * Closure
-   */
-  void *cls;
-
-  /**
-   * The next pointer for DLL
-   */
-  struct DLLOperation *next;
-
-  /**
-   * The prev pointer for DLL
-   */
-  struct DLLOperation *prev;
-};
-
-
-/**
- * Availanle states during profiling
- */
-enum State
-{
-  /**
-   * Initial state
-   */
-  STATE_INIT = 0,
-
-  /**
-   * Starting slaves
-   */
-  STATE_SLAVES_STARTING,
-
-  /**
-   * Creating peers
-   */
-  STATE_PEERS_CREATING,
-
-  /**
-   * Starting peers
-   */
-  STATE_PEERS_STARTING,
-
-  /**
-   * Linking peers
-   */
-  STATE_PEERS_LINKING,
-
-  /**
-   * Destroying peers; we can do this as the controller takes care of stopping a
-   * peer if it is running
-   */
-  STATE_PEERS_DESTROYING
-};
-
-
-/**
- * An array of hosts loaded from the hostkeys file
- */
-static struct GNUNET_TESTBED_Host **hosts;
-
-/**
- * The array of peers; we fill this as the peers are given to us by the testbed
- */
-static struct GNUNET_TESTBED_Peer **peers;
-
-/* /\** */
-/*  * Operation handle */
-/*  *\/ */
-/* static struct GNUNET_TESTBED_Operation *op; */
-
-/**
- * Host registration handle
- */
-static struct GNUNET_TESTBED_HostRegistrationHandle *reg_handle;
-
-/**
- * Handle to the master controller process
- */
-struct GNUNET_TESTBED_ControllerProc *mc_proc;
-
-/**
- * Handle to the master controller
- */
-struct GNUNET_TESTBED_Controller *mc;
-
-/**
  * Handle to global configuration
  */
 struct GNUNET_CONFIGURATION_Handle *cfg;
 
 /**
- * Head of the operations list
- */
-struct DLLOperation *dll_op_head;
-
-/**
- * Tail of the operations list
- */
-struct DLLOperation *dll_op_tail;
-
-/**
  * Peer linking - topology operation
  */
 struct GNUNET_TESTBED_Operation *topology_op;
 
 /**
- * The handle for whether a host is habitable or not
- */
-struct GNUNET_TESTBED_HostHabitableCheckHandle **hc_handles;
-
-/**
  * Abort task identifier
  */
 static GNUNET_SCHEDULER_TaskIdentifier abort_task;
@@ -168,46 +58,16 @@ static GNUNET_SCHEDULER_TaskIdentifier abort_task;
 static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
 
 /**
- * Host registration task identifier
- */
-static GNUNET_SCHEDULER_TaskIdentifier register_hosts_task;
-
-/**
  * Global event mask for all testbed events
  */
 uint64_t event_mask;
 
 /**
- * The starting time of a profiling step
- */
-struct GNUNET_TIME_Absolute prof_start_time;
-
-/**
- * Duration profiling step has taken
- */
-struct GNUNET_TIME_Relative prof_time;
-
-/**
- * Current peer id
- */
-unsigned int peer_id;
-
-/**
  * Number of peers to be started by the profiler
  */
 static unsigned int num_peers;
 
 /**
- * Number of hosts in the hosts array
- */
-static unsigned int num_hosts;
-
-/**
- * Number of random links to be established between peers
- */
-static unsigned int num_links;
-
-/**
  * Number of timeout failures to tolerate
  */
 static unsigned int num_cont_fails;
@@ -232,16 +92,6 @@ static unsigned int failed_links;
  */
 static int result;
 
-/**
- * current state of profiling
- */
-enum State state;
-
-/**
- * The topology we want to acheive
- */
-enum GNUNET_TESTBED_TopologyOption topology;
-
 
 /**
  * Shutdown nicely
@@ -252,40 +102,9 @@ enum GNUNET_TESTBED_TopologyOption topology;
 static void
 do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct DLLOperation *dll_op;
-  unsigned int nhost;
-
   shutdown_task = GNUNET_SCHEDULER_NO_TASK;
   if (GNUNET_SCHEDULER_NO_TASK != abort_task)
     GNUNET_SCHEDULER_cancel (abort_task);
-  if (NULL != hc_handles)
-  {
-    for (nhost = 0; nhost < num_hosts; nhost++)
-      if (NULL != hc_handles[nhost])
-        GNUNET_TESTBED_is_host_habitable_cancel (hc_handles[nhost]);
-    GNUNET_free (hc_handles);
-    hc_handles = NULL;
-  }
-  if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
-    GNUNET_SCHEDULER_cancel (register_hosts_task);
-  if (NULL != reg_handle)
-    GNUNET_TESTBED_cancel_registration (reg_handle);
-  if (NULL != topology_op)
-    GNUNET_TESTBED_operation_done (topology_op);
-  for (nhost = 0; nhost < num_hosts; nhost++)
-    if (NULL != hosts[nhost])
-      GNUNET_TESTBED_host_destroy (hosts[nhost]);
-  GNUNET_free_non_null (hosts);
-  while (NULL != (dll_op = dll_op_head))
-  {
-    GNUNET_TESTBED_operation_done (dll_op->op);
-    GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
-    GNUNET_free (dll_op);
-  }
-  if (NULL != mc)
-    GNUNET_TESTBED_controller_disconnect (mc);
-  if (NULL != mc_proc)
-    GNUNET_TESTBED_controller_stop (mc_proc);
   if (NULL != cfg)
     GNUNET_CONFIGURATION_destroy (cfg);
   GNUNET_SCHEDULER_shutdown ();	/* Stop scheduler to shutdown testbed run */
@@ -311,129 +130,6 @@ do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 /**
- * Functions of this signature are called when a peer has been successfully
- * started or stopped.
- *
- * @param cls the closure from GNUNET_TESTBED_peer_start/stop()
- * @param emsg NULL on success; otherwise an error description
- */
-static void 
-peer_churn_cb (void *cls, const char *emsg)
-{
-  struct DLLOperation *dll_op = cls;
-  struct GNUNET_TESTBED_Operation *op;  
-  static unsigned int started_peers;
-
-  op = dll_op->op;
-  GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
-  GNUNET_free (dll_op);
-  if (NULL != emsg)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("An operation has failed while starting peers\n"));
-    GNUNET_TESTBED_operation_done (op);
-    GNUNET_SCHEDULER_cancel (abort_task);
-    abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-    return;
-  }
-  GNUNET_TESTBED_operation_done (op);
-  if (++started_peers == num_peers)
-  {
-    prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
-    printf ("%u peers started successfully in %.2f seconds\n",
-            num_peers, ((double) prof_time.rel_value) / 1000.00);
-    fflush (stdout);
-    result = GNUNET_OK;
-    if ((0 == num_links) && (topology == GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI))
-    { 
-      fprintf (stdout, "Testbed running, waiting for keystroke to shut down\n");
-      (void) getc (stdin);
-      shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
-      return;
-    }
-    state = STATE_PEERS_LINKING;
-    /* Do overlay connect */
-    prof_start_time = GNUNET_TIME_absolute_get ();
-    switch (topology)
-    {
-    case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
-      topology_op =
-          GNUNET_TESTBED_overlay_configure_topology (NULL, num_peers, peers, NULL,
-                                                     topology,
-                                                     num_links,
-                                                     GNUNET_TESTBED_TOPOLOGY_DISABLE_AUTO_RETRY,
-                                                     GNUNET_TESTBED_TOPOLOGY_OPTION_END);
-      break;
-    case GNUNET_TESTBED_TOPOLOGY_CLIQUE:
-      topology_op =
-          GNUNET_TESTBED_overlay_configure_topology (NULL, num_peers, peers, NULL,
-                                                     topology,
-                                                     GNUNET_TESTBED_TOPOLOGY_DISABLE_AUTO_RETRY,
-                                                     GNUNET_TESTBED_TOPOLOGY_OPTION_END);
-      num_links = num_peers * (num_peers - 1);
-      break;
-    default:
-      GNUNET_assert (0);
-    }
-  }
-}
-
-
-/**
- * Functions of this signature are called when a peer has been successfully
- * created
- *
- * @param cls the closure from GNUNET_TESTBED_peer_create()
- * @param peer the handle for the created peer; NULL on any error during
- *          creation
- * @param emsg NULL if peer is not NULL; else MAY contain the error description
- */
-static void 
-peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
-{
-  struct DLLOperation *dll_op = cls;
-  struct GNUNET_TESTBED_Peer **peer_ptr;
-  static unsigned int created_peers;
-  unsigned int peer_cnt;
-
-  if (NULL != emsg)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Creating a peer failed. Error: %s\n"), emsg);
-    GNUNET_TESTBED_operation_done (dll_op->op);
-    GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
-    GNUNET_free (dll_op);
-    GNUNET_SCHEDULER_cancel (abort_task);
-    abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-    return;
-  }
-  peer_ptr = dll_op->cls;
-  GNUNET_assert (NULL == *peer_ptr);
-  *peer_ptr = peer;
-  GNUNET_TESTBED_operation_done (dll_op->op);
-  GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
-  GNUNET_free (dll_op);
-  if (++created_peers == num_peers)
-  {
-    prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);    
-    printf ("%u peers created successfully in %.2f seconds\n",
-            num_peers, ((double) prof_time.rel_value) / 1000.00);
-    fflush (stdout);
-    /* Now peers are to be started */
-    state = STATE_PEERS_STARTING;
-    prof_start_time = GNUNET_TIME_absolute_get ();
-    for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
-    {
-      dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
-      dll_op->op = GNUNET_TESTBED_peer_start (dll_op, peers[peer_cnt], 
-                                              &peer_churn_cb, dll_op);
-      GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op);
-    }
-  }
-}
-
-
-/**
  * Function to print summary about how many overlay links we have made and how
  * many failed
  */
@@ -445,42 +141,11 @@ print_overlay_links_summary ()
   if (GNUNET_YES == printed_already)
     return;
   printed_already = GNUNET_YES;
-  prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
-  printf ("\n%u links established in %.2f seconds\n",
-	  established_links, ((double) prof_time.rel_value) / 1000.00);
   printf ("%u links failed due to timeouts\n", failed_links);
 }
 
 
 /**
- * Function to start peers
- */
-static void
-start_peers ()
-{
-  struct DLLOperation *dll_op;
-  unsigned int peer_cnt;
-  
-  state = STATE_PEERS_CREATING;
-  prof_start_time = GNUNET_TIME_absolute_get ();
-  peers = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer *)
-                         * num_peers);
-  for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
-  {
-    dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
-    dll_op->cls = &peers[peer_cnt];
-    dll_op->op = GNUNET_TESTBED_peer_create (mc,
-                                             hosts
-                                             [peer_cnt % num_hosts],
-                                             cfg,
-                                             &peer_create_cb,
-                                             dll_op);
-    GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op);
-  }
-}
-
-
-/**
  * Controller event callback
  *
  * @param cls NULL
@@ -490,265 +155,60 @@ static void
 controller_event_cb (void *cls,
                      const struct GNUNET_TESTBED_EventInformation *event)
 {
-  struct DLLOperation *dll_op;
-  struct GNUNET_TESTBED_Operation *op;
-
-  switch (state)
+  switch (event->type)
   {
-  case STATE_SLAVES_STARTING:
-    switch (event->type)
+  case GNUNET_TESTBED_ET_OPERATION_FINISHED:
+    /* Control reaches here when a peer linking operation fails */
+    if (NULL != event->details.operation_finished.emsg)
     {
-    case GNUNET_TESTBED_ET_OPERATION_FINISHED:
+      printf ("F");
+      fflush (stdout);
+      failed_links++;
+      if (++cont_fails > num_cont_fails)
       {
-        static unsigned int slaves_started;
-        
-        dll_op = event->details.operation_finished.op_cls;
-        GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
-        GNUNET_free (dll_op);
-        op = event->details.operation_finished.operation;
-        if (NULL != event->details.operation_finished.emsg)
-        {
-          LOG (GNUNET_ERROR_TYPE_WARNING,
-               _("An operation has failed while starting slaves\n"));
-	  GNUNET_TESTBED_operation_done (op);
-          GNUNET_SCHEDULER_cancel (abort_task);
-          abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-          return;
-        }
-	GNUNET_TESTBED_operation_done (op);
-        /* Proceed to start peers */
-        if (++slaves_started == num_hosts - 1)
-        {
-          printf ("%u controllers started successfully\n", num_hosts);
-	  fflush (stdout);
-          start_peers ();
-        }
+        printf ("\nAborting due to very high failure rate");
+        print_overlay_links_summary ();	  
+        GNUNET_SCHEDULER_cancel (abort_task);
+        abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
+        return;
       }
-      break;
-    default:
-      GNUNET_assert (0);
     }
     break;
-  case STATE_PEERS_STARTING:
-    switch (event->type)
-    {
-    case GNUNET_TESTBED_ET_OPERATION_FINISHED:
-      /* Control reaches here when peer start fails */
-    case GNUNET_TESTBED_ET_PEER_START:
-      /* we handle peer starts in peer_churn_cb */
-      break;
-    default:
-      GNUNET_assert (0);
-    }
-    break;
-  case STATE_PEERS_LINKING:
-    switch (event->type)
-    {
-    case GNUNET_TESTBED_ET_OPERATION_FINISHED:
-      /* Control reaches here when a peer linking operation fails */
-      if (NULL != event->details.operation_finished.emsg)
-      {
-	printf ("F");
-	fflush (stdout);
-        failed_links++;
-	if (++cont_fails > num_cont_fails)
-	{
-	  printf ("\nAborting due to very high failure rate");
-	  print_overlay_links_summary ();	  
-	  GNUNET_SCHEDULER_cancel (abort_task);
-	  abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-	  return;
-	}
-      }
-      break;
-    case GNUNET_TESTBED_ET_CONNECT:
-      {
-	if (0 != cont_fails)
-	  cont_fails--;
-	if (0 == established_links)
-	  printf ("Establishing links. Please wait\n");
-	printf (".");
-	fflush (stdout);
-        established_links++;
-      }
-      break;
-    default:
-      GNUNET_assert (0);
-    }
-    if ((established_links + failed_links) == num_links)
+  case GNUNET_TESTBED_ET_CONNECT:
     {
-      print_overlay_links_summary ();
-      result = GNUNET_OK;
-      fprintf (stdout, "Testbed running, waiting for keystroke to shut down\n");
+      if (0 != cont_fails)
+        cont_fails--;
+      if (0 == established_links)
+        printf ("Establishing links. Please wait\n");
+      printf (".");
       fflush (stdout);
-      (void) getc (stdin);
-      shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
-    }    
+      established_links++;
+    }
     break;
   default:
-    GNUNET_assert (0);
-  }
-}
-
-
-/**
- * Task to register all hosts available in the global host list
- *
- * @param cls NULL
- * @param tc the scheduler task context
- */
-static void
-register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
-
-
-/**
- * Callback which will be called to after a host registration succeeded or failed
- *
- * @param cls the closure
- * @param emsg the error message; NULL if host registration is successful
- */
-static void
-host_registration_completion (void *cls, const char *emsg)
-{
-  reg_handle = NULL;
-  if (NULL != emsg)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Host registration failed for a host. Error: %s\n"), emsg);
-    GNUNET_SCHEDULER_cancel (abort_task);
-    abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-    return;
-  }
-  register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, NULL);
-}
-
-
-/**
- * Task to register all hosts available in the global host list
- *
- * @param cls NULL
- * @param tc the scheduler task context
- */
-static void
-register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct DLLOperation *dll_op;
-  static unsigned int reg_host;
-  unsigned int slave;
-
-  register_hosts_task = GNUNET_SCHEDULER_NO_TASK;  
-  if (reg_host == num_hosts - 1)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "All hosts successfully registered\n");
-    /* Start slaves */
-    state = STATE_SLAVES_STARTING;
-    for (slave = 1; slave < num_hosts; slave++)
-    {
-      dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
-      dll_op->op = GNUNET_TESTBED_controller_link (dll_op,
-                                                   mc,
-                                                   hosts[slave],
-                                                   hosts[0],
-                                                   cfg,
-                                                   GNUNET_YES);
-      GNUNET_CONTAINER_DLL_insert_tail (dll_op_head, dll_op_tail, dll_op);
-    }
-    return;
-  }
-  reg_handle = GNUNET_TESTBED_register_host (mc, hosts[++reg_host],
-                                             host_registration_completion,
-                                             NULL);
-}
-
-
-/**
- * Callback to signal successfull startup of the controller process
- *
- * @param cls the closure from GNUNET_TESTBED_controller_start()
- * @param config the configuration with which the controller has been started;
- *          NULL if status is not GNUNET_OK
- * @param status GNUNET_OK if the startup is successfull; GNUNET_SYSERR if not,
- *          GNUNET_TESTBED_controller_stop() shouldn't be called in this case
- */
-static void
-status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config, int status)
-{
-  if (GNUNET_SCHEDULER_NO_TASK != abort_task)
-    GNUNET_SCHEDULER_cancel (abort_task);
-  if (GNUNET_OK != status)
-  {
-    mc_proc = NULL;
-    abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-    return;
-  }
-  event_mask = 0;
-  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
-  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
-  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
-  event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
-  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
-  mc = GNUNET_TESTBED_controller_connect (config, hosts[0], event_mask,
-                                          &controller_event_cb, NULL);
-  if (NULL == mc)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Unable to connect to master controller -- Check config\n"));
-    abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-    return;
+    GNUNET_break (0);
   }
-  if (num_hosts > 1)
-    register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, NULL);
-  else
-    start_peers ();
-  abort_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                             &do_abort, NULL);
 }
 
 
 /**
- * Callbacks of this type are called by GNUNET_TESTBED_is_host_habitable to
- * inform whether the given host is habitable or not. The Handle returned by
- * GNUNET_TESTBED_is_host_habitable() is invalid after this callback is called
+ * Signature of a main function for a testcase.
  *
- * @param cls NULL
- * @param host the host whose status is being reported; will be NULL if the host
- *          given to GNUNET_TESTBED_is_host_habitable() is NULL
- * @param status GNUNET_YES if it is habitable; GNUNET_NO if not
+ * @param cls closure
+ * @param num_peers number of peers in 'peers'
+ * @param peers handle to peers run in the testbed
  */
-static void 
-host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host, int status)
+static void test_run (void *cls,
+                      unsigned int num_peers,
+                      struct GNUNET_TESTBED_Peer **peers)
 {
-  struct GNUNET_TESTBED_HostHabitableCheckHandle **hc_handle = cls;
-  static unsigned int hosts_checked;
-
-  *hc_handle = NULL;
-  if (GNUNET_NO == status)
-  {
-    if ((NULL != host) && (NULL != GNUNET_TESTBED_host_get_hostname (host)))
-      LOG (GNUNET_ERROR_TYPE_ERROR, _("Host %s cannot start testbed\n"),
-           GNUNET_TESTBED_host_get_hostname (host));
-    else
-      LOG (GNUNET_ERROR_TYPE_ERROR, _("Testbed cannot be started on localhost\n"));
-    GNUNET_SCHEDULER_cancel (abort_task);
-    abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
-    return;
-  }
-  hosts_checked++;
-  printf (_("\rChecked %u hosts"), hosts_checked);
+  result = GNUNET_OK;
+  fprintf (stdout, "\nTestbed running, waiting for keystroke to shut down\n");
   fflush (stdout);
-  if (hosts_checked < num_hosts)
-    return;
-  printf (_("\nAll hosts can start testbed. Creating peers\n"));
-  GNUNET_free (hc_handles);
-  hc_handles = NULL;
-  mc_proc = 
-      GNUNET_TESTBED_controller_start (GNUNET_TESTBED_host_get_hostname 
-                                       (hosts[0]),
-                                       hosts[0],
-                                       cfg,
-                                       status_cb,
-                                       NULL);
+  (void) getc (stdin);
+  fprintf (stdout, "Shutting down. Please wait\n");
+  fflush (stdout);
+  shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
 }
 
 
@@ -764,8 +224,6 @@ static void
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *config)
 {
-  unsigned int nhost;
-
   if (NULL == args[0])
   {
     fprintf (stderr, _("No hosts-file specified on command line\n"));
@@ -776,81 +234,22 @@ run (void *cls, char *const *args, const char *cfgfile,
     result = GNUNET_OK;
     return;
   }
-  num_hosts = GNUNET_TESTBED_hosts_load_from_file (args[0], &hosts);
-  if (0 == num_hosts)
-  {
-    fprintf (stderr, _("No hosts loaded. Need at least one host\n"));
-    return;
-  }
-  printf (_("Checking whether given hosts can start testbed. Please wait\n"));
-  hc_handles = GNUNET_malloc (sizeof (struct
-                                      GNUNET_TESTBED_HostHabitableCheckHandle *) 
-                              * num_hosts);
-  for (nhost = 0; nhost < num_hosts; nhost++)
-  {
-    if (NULL == (hc_handles[nhost] = GNUNET_TESTBED_is_host_habitable (hosts[nhost], config,
-                                                                       &host_habitable_cb,
-                                                                       &hc_handles[nhost])))
-    {
-      GNUNET_break (0);
-      for (nhost = 0; nhost < num_hosts; nhost++)
-        if (NULL != hc_handles[nhost])
-          GNUNET_TESTBED_is_host_habitable_cancel (hc_handles[nhost]);
-      GNUNET_free (hc_handles);
-      hc_handles = NULL;
-      break;
-    }
-  }
-  if (num_hosts != nhost)
-  {
-    fprintf (stderr, _("Exiting\n"));
-    shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
-    return;
-  }
   cfg = GNUNET_CONFIGURATION_dup (config);
+  event_mask = 0;
+  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
+  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
+  GNUNET_TESTBED_run (args[0], cfg, 
+                      num_peers, event_mask,
+                      controller_event_cb, NULL,
+                      &test_run, NULL);
   abort_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_SECONDS, 5), &do_abort,
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    &do_abort,
                                     NULL);
 }
 
 
 /**
- * Set an option of type 'char *' from the command line.
- * A pointer to this function should be passed as part of the
- * 'struct GNUNET_GETOPT_CommandLineOption' array to initialize options
- * of this type.  It should be followed by a pointer to a value of
- * type 'char *'.
- *
- * @param ctx command line processing context
- * @param scls additional closure (will point to the 'char *',
- *             which will be allocated)
- * @param option name of the option
- * @param value actual value of the option (a string)
- * @return GNUNET_OK to continue procesing; GNUNET_SYSERR to signal error
- */
-int
-set_topology (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-              void *scls, const char *option, const char *value)
-{
-  enum GNUNET_TESTBED_TopologyOption *val = scls;
-
-  if (0 == strncasecmp ("CLIQUE", value, strlen ("CLIQUE")))
-  {  
-    *val = GNUNET_TESTBED_TOPOLOGY_CLIQUE;
-    return GNUNET_OK;
-  }
-  if (0 == strncasecmp ("RANDOM", value, strlen ("RANDOM")))
-  {  
-    *val = GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI;
-    return GNUNET_OK;
-  }
-  FPRINTF (stderr, "%s", _("Only `CLIQUE' and `RANDOM' are permitted.\n"));
-  return GNUNET_SYSERR;
-}
-
-
-/**
  * Main function.
  *
  * @return 0 on success
@@ -862,25 +261,15 @@ main (int argc, char *const *argv)
     { 'p', "num-peers", "COUNT",
       gettext_noop ("create COUNT number of peers"),
       GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_peers },
-    { 'n', "num-links", "COUNT",
-      gettext_noop ("create COUNT number of random links"),
-      GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_links },
     { 'e', "num-errors", "COUNT",
       gettext_noop ("tolerate COUNT number of continious timeout failures"),
       GNUNET_YES, &GNUNET_GETOPT_set_uint, &num_cont_fails },
-    { 't', "topology", "TOPOLOGY",
-      gettext_noop ("Try to acheive TOPOLOGY. This options takes either CLIQUE "
-                    "or RANDOM. For CLIQUE the parameter -n is ignored. The "
-                    "default is to acheive a random graph topology."),
-      GNUNET_YES, &set_topology, &topology },
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
 
-  topology = GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI;
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
-    return 2;
-  
+    return 2;  
   result = GNUNET_SYSERR;
   ret =
       GNUNET_PROGRAM_run (argc, argv, "gnunet-testbed-profiler [OPTIONS] hosts-file",
diff --git a/src/testbed/testbed_api_testbed.c b/src/testbed/testbed_api_testbed.c
index 194d54a587..1066316045 100644
--- a/src/testbed/testbed_api_testbed.c
+++ b/src/testbed/testbed_api_testbed.c
@@ -26,6 +26,7 @@
  */
 
 #include "platform.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_testbed_service.h"
 #include "testbed_api_peers.h"
 #include "testbed_api_hosts.h"
@@ -37,6 +38,11 @@
 #define LOG(kind,...)                                           \
   GNUNET_log_from (kind, "testbed-api-testbed", __VA_ARGS__)
 
+/**
+ * Debug logging shortcut
+ */
+#define DEBUG(...)                              \
+  LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
 
 /**
  * DLL of operations
@@ -198,6 +204,11 @@ struct RunContext
   struct GNUNET_TESTBED_HostRegistrationHandle *reg_handle;
 
   /**
+   * Profiling start time
+   */
+  struct GNUNET_TIME_Absolute pstart_time;
+
+  /**
    * Host registration task
    */
   GNUNET_SCHEDULER_TaskIdentifier register_hosts_task;
@@ -281,7 +292,8 @@ start_peers_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct DLLOperation *dll_op;
   unsigned int peer;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting Peers\n");
+  DEBUG ("Starting Peers\n");
+  rc->pstart_time = GNUNET_TIME_absolute_get ();
   for (peer = 0; peer < rc->num_peers; peer++)
   {
     dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
@@ -307,6 +319,7 @@ peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
 {
   struct DLLOperation *dll_op = cls;
   struct RunContext *rc;
+  struct GNUNET_TIME_Relative ptime;
 
   GNUNET_assert (NULL != dll_op);
   rc = dll_op->rc;
@@ -326,7 +339,9 @@ peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
   rc->peer_count++;
   if (rc->peer_count < rc->num_peers)
     return;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "%u peers created successfully\n", rc->num_peers);
+  ptime = GNUNET_TIME_absolute_get_duration (rc->pstart_time);
+  DEBUG ("%u peers created in %s\n", rc->num_peers,
+         GNUNET_STRINGS_relative_time_to_string (ptime, GNUNET_YES));
   GNUNET_SCHEDULER_add_now (&start_peers_task, rc);
 }
 
@@ -485,7 +500,7 @@ shutdown_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
           rc->peer_count++;
           continue;
         }
-        LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping peer %u\n", peer);
+        DEBUG ("Stopping peer %u\n", peer);
         dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
         dll_op->op = GNUNET_TESTBED_peer_stop (rc->peers[peer], NULL, NULL);
         dll_op->cls = rc->peers[peer];
@@ -535,7 +550,9 @@ create_peers (struct RunContext *rc)
 {
   struct DLLOperation *dll_op;
   unsigned int peer;
-
+ 
+  DEBUG ("Creating peers\n");
+  rc->pstart_time = GNUNET_TIME_absolute_get ();
   rc->peers =
       GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer *) * rc->num_peers);
   GNUNET_assert (NULL != rc->c);
@@ -618,7 +635,7 @@ event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
       GNUNET_SCHEDULER_add_continuation (&call_master, rc,
                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
     }
-    return;
+    goto call_cc;
   }
   for (dll_op = rc->dll_op_head; NULL != dll_op; dll_op = dll_op->next)
   {
@@ -655,7 +672,7 @@ event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
     rc->state = RC_PEERS_DESTROYED;
     GNUNET_free (rc->peers);
     rc->peers = NULL;
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully destroyed\n");
+    DEBUG ("All peers successfully destroyed\n");
     GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
     break;
   default:
@@ -679,8 +696,11 @@ call_cc:
   GNUNET_free (dll_op);
   rc->peer_count++;
   if (rc->peer_count < rc->num_peers)
-    return;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Peers started successfully\n");
+    return;  
+  DEBUG ("%u peers started in %s\n", rc->num_peers,
+         GNUNET_STRINGS_relative_time_to_string
+         (GNUNET_TIME_absolute_get_duration(rc->pstart_time),
+          GNUNET_YES));
   if (GNUNET_TESTBED_TOPOLOGY_NONE != rc->topology)
   {
     if ( (GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI == rc->topology)
@@ -777,8 +797,7 @@ register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   rc->register_hosts_task = GNUNET_SCHEDULER_NO_TASK;
   if (rc->reg_hosts == rc->num_hosts)
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "All hosts successfully registered\n");
+    DEBUG ("All hosts successfully registered\n");
     /* Start slaves */
     for (slave = 0; slave < rc->num_hosts; slave++)
     {