X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2d5d09100c0bb575a15c897ee21f9015d86f8fd1..6d14c1b85abceee6c22915a6d8e8c4d49e8f3b03:/tools/tesh/run_context.c

diff --git a/tools/tesh/run_context.c b/tools/tesh/run_context.c
index f734a41c16..6f046dfa49 100644
--- a/tools/tesh/run_context.c
+++ b/tools/tesh/run_context.c
@@ -1,6 +1,6 @@
 /* run_context -- stuff in which TESH runs a command                        */
 
-/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+/* Copyright (c) 2007-2014. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -13,6 +13,7 @@
 #include <sys/wait.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <math.h>               /* floor */
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(tesh);
 
@@ -78,13 +79,13 @@ void rctx_init(void)
   struct sigaction newact;
   int i;
   fg_job = 0;
-  bg_jobs = xbt_dynar_new_sync(sizeof(rctx_t), kill_it);
+  bg_jobs = xbt_dynar_new(sizeof(rctx_t), kill_it);
   armageddon_mutex = xbt_os_mutex_init();
   armageddon_initiator = NULL;
   sigwaiter_mutex = xbt_os_mutex_init();
   sigwaiter_cond = xbt_os_cond_init();
   xbt_os_mutex_acquire(sigwaiter_mutex);
-  sigwaiter_thread = xbt_os_thread_create("Armaggedon request waiter",
+  sigwaiter_thread = xbt_os_thread_create("Armageddon request waiter",
                                           armageddon_sigwaiter, NULL, NULL);
   /* Wait for thread to start... */
   xbt_os_cond_wait(sigwaiter_cond, sigwaiter_mutex);
@@ -115,7 +116,7 @@ void rctx_wait_bg(void)
 {
   /* Do not use xbt_dynar_free or it will lock the dynar, preventing armageddon
    * from working */
-  while (xbt_dynar_length(bg_jobs)) {
+  while (!xbt_dynar_is_empty(bg_jobs)) {
     rctx_t rctx = xbt_dynar_getlast_as(bg_jobs, rctx_t);
     wait_it(rctx);
     xbt_dynar_pop(bg_jobs, &rctx);
@@ -133,7 +134,10 @@ static void rctx_armageddon_kill_one(rctx_t initiator, const char *filepos,
     if (!rctx->reader_done) {
       rctx->interrupted = 1;
       kill(rctx->pid, SIGTERM);
-      usleep(100);
+      struct timespec ts;
+      ts.tv_sec = 0;
+      ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9;
+      nanosleep (&ts, NULL);
       kill(rctx->pid, SIGKILL);
     }
     xbt_os_mutex_release(rctx->interruption);
@@ -169,7 +173,10 @@ void rctx_armageddon(rctx_t initiator, int exitcode)
   }
 
   /* Give runner threads a chance to acknowledge the processes deaths */
-  usleep(10000);
+  struct timespec ts;
+  ts.tv_sec = 0;
+  ts.tv_nsec = (10000e-6 - floor(10000e-6)) * 1e9;
+  nanosleep (&ts, NULL);
   /* Ensure that nobody is running rctx_wait on exit */
   if (fg_job)
     xbt_os_mutex_acquire(rctx->interruption);
@@ -189,14 +196,12 @@ void rctx_empty(rctx_t rc)
   char **env_it;
   void *filepos;
 
-  if (rc->cmd)
-    free(rc->cmd);
+  free(rc->cmd);
   rc->cmd = NULL;
   /* avoid race with rctx_armageddon log messages */
   filepos = rc->filepos;
   rc->filepos = NULL;
-  if (filepos)
-    free(filepos);
+  free(filepos);
   for (i = 0, env_it = environ; *env_it; i++, env_it++);
   if (rc->env) {
     for (env_it = rctx->env + i; *env_it; env_it++)
@@ -241,10 +246,8 @@ void rctx_free(rctx_t rctx)
   if (!rctx)
     return;
 
-  if (rctx->cmd)
-    free(rctx->cmd);
-  if (rctx->filepos)
-    free(rctx->filepos);
+  free(rctx->cmd);
+  free(rctx->filepos);
   if (rctx->env) {
     int i;
     char **env_it;
@@ -302,8 +305,10 @@ void rctx_pushline(const char *filepos, char kind, char *line)
 
     rctx->cmd = xbt_strdup(line);
     rctx->filepos = xbt_strdup(filepos);
-    if(option){
-    	rctx->cmd = bprintf("%s %s",rctx->cmd,option);
+    if (option){
+      char *newcmd = bprintf("%s %s", rctx->cmd, option);
+      free(rctx->cmd);
+      rctx->cmd = newcmd;
     }
     XBT_INFO("[%s] %s%s", filepos, rctx->cmd,
           ((rctx->is_background) ? " (background command)" : ""));
@@ -320,6 +325,7 @@ void rctx_pushline(const char *filepos, char kind, char *line)
     rctx->is_empty = 0;
     xbt_strbuff_append(rctx->output_wanted, line);
     xbt_strbuff_append(rctx->output_wanted, "\n");
+    XBT_DEBUG("wanted:%s",rctx->output_wanted->data);
     break;
 
   case '!':
@@ -363,7 +369,7 @@ void rctx_pushline(const char *filepos, char kind, char *line)
       int len = strlen("setenv ");
       char *eq = strchr(line + len, '=');
       char *key = bprintf("%.*s", (int) (eq - line - len), line + len);
-      xbt_dict_set(env, key, xbt_strdup(eq + 1), xbt_free_f);
+      xbt_dict_set(env, key, xbt_strdup(eq + 1), NULL);
       free(key);
 
       rctx->env = realloc(rctx->env, ++(rctx->env_size) * sizeof(char *));
@@ -412,8 +418,12 @@ static void *thread_writer(void *r)
     }
     XBT_DEBUG("written %d chars so far", posw);
 
-    if (got <= 0)
-      usleep(100);
+    if (got <= 0){
+      struct timespec ts;
+      ts.tv_sec = 0;
+      ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9;
+      nanosleep (&ts, NULL);
+    }
   }
   rctx->input->data[0] = '\0';
   rctx->input->used = 0;
@@ -440,7 +450,10 @@ static void *thread_reader(void *r)
       buffout[posr] = '\0';
       xbt_strbuff_append(rctx->output_got, buffout);
     } else {
-      usleep(100);
+      struct timespec ts;
+      ts.tv_sec = 0;
+      ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9;
+      nanosleep (&ts, NULL);
     }
   } while (!rctx->timeout && posr != 0);
   free(buffout);
@@ -526,8 +539,7 @@ static void start_command(rctx_t rctx)
         xbt_dynar_t path = xbt_str_split(environ[i] + 5, ":");
 
         xbt_dynar_foreach(path, it, str) {
-          if (binary_name)
-            free(binary_name);
+          free(binary_name);
           binary_name = bprintf("%s/%s", str, args[0]);
           if (!stat(binary_name, &stat_buf)) {
             /* Found. */
@@ -565,7 +577,9 @@ void rctx_start(void)
   int child_out[2];
 
   XBT_DEBUG("Cmd before rewriting %s", rctx->cmd);
-  rctx->cmd = xbt_str_varsubst(rctx->cmd, env);
+  char *newcmd = xbt_str_varsubst(rctx->cmd, env);
+  free(rctx->cmd);
+  rctx->cmd = newcmd;
   XBT_VERB("Start %s %s", rctx->cmd,
         (rctx->is_background ? "(background job)" : ""));
   xbt_os_mutex_acquire(armageddon_mutex);
@@ -648,20 +662,35 @@ void rctx_start(void)
 
 /* Helper function to sort the output */
 static int cmpstringp(const void *p1, const void *p2) {
-  /* Sort only using the 19 first chars (date+pid)
-   * If the dates are the same, then, sort using pointer address (be stable wrt output of each process)
+  /* Sort only using the sort_len first chars
+   * If they are the same, then, sort using pointer address
+   * (be stable wrt output of each process)
    */
-  const char *s1 = *((const char**) p1);
-  const char *s2 = *((const char**) p2);
+  const char **s1 = *(const char***)p1;
+  const char **s2 = *(const char***)p2;
 
-  XBT_DEBUG("Compare strings '%s' and '%s'", s1, s2);
+  XBT_DEBUG("Compare strings '%s' and '%s'", *s1, *s2);
 
-  int res = strncmp(s1, s2, sort_len);
+  int res = strncmp(*s1, *s2, sort_len);
   if (res == 0)
-    return p1>p2;
+    res = s1 > s2 ? 1 : (s1 < s2 ? -1 : 0);
   return res;
 }
 
+static void stable_sort(xbt_dynar_t a)
+{
+  unsigned long len = xbt_dynar_length(a);
+  void **b = xbt_new(void*, len);
+  unsigned long i;
+  for (i = 0 ; i < len ; i++)   /* fill the array b with pointers to strings */
+    b[i] = xbt_dynar_get_ptr(a, i);
+  qsort(b, len, sizeof *b, cmpstringp); /* sort it */
+  for (i = 0 ; i < len ; i++) /* dereference the pointers to get the strings */
+    b[i] = *(char**)b[i];
+  for (i = 0 ; i < len ; i++)   /* put everything in place */
+    xbt_dynar_set_as(a, i, char*, b[i]);
+  xbt_free(b);
+}
 
 /* Waits for the child to end (or to timeout), and check its
    ending conditions. This is launched from rctx_start but either in main
@@ -683,7 +712,10 @@ void *rctx_wait(void *r)
   /* Wait for the child to die or the timeout to happen (or an armageddon to happen) */
   while (!rctx->reader_done
          && (rctx->end_time < 0 || rctx->end_time >= now)) {
-    usleep(100);
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9;
+    nanosleep (&ts, NULL);
     now = time(NULL);
   }
 
@@ -692,7 +724,10 @@ void *rctx_wait(void *r)
     XBT_INFO("<%s> timeouted. Kill the process.", rctx->filepos);
     rctx->timeout = 1;
     kill(rctx->pid, SIGTERM);
-    usleep(100);
+    struct timespec ts;
+    ts.tv_sec = 0;
+    ts.tv_nsec = (100e-6 - floor(100e-6)) * 1e9;
+    nanosleep (&ts, NULL);
     kill(rctx->pid, SIGKILL);
   }
 
@@ -707,7 +742,7 @@ void *rctx_wait(void *r)
      return NULL;
      xbt_os_mutex_acquire(rctx->interruption); */
 
-  {
+  { // Sorting output got
     xbt_dynar_t a = xbt_str_split(rctx->output_got->data, "\n");
     xbt_dynar_t b = xbt_dynar_new(sizeof(char *), NULL);
     unsigned cpt;
@@ -725,7 +760,7 @@ void *rctx_wait(void *r)
     }
 
     if (rctx->output_sort) {
-      xbt_dynar_sort(b, cmpstringp);
+      stable_sort(b);
       /* If empty lines moved in first position, remove them */
       while (!xbt_dynar_is_empty(b) && *xbt_dynar_getfirst_as(b, char*) == '\0')
         xbt_dynar_shift(b, NULL);
@@ -742,10 +777,24 @@ void *rctx_wait(void *r)
     xbt_dynar_free(&a);
   }
 
+  if (rctx->output_sort) { // Sorting output wanted
+    char *newbuf;
+    xbt_dynar_t a = xbt_str_split(rctx->output_wanted->data, "\n");
+
+    stable_sort(a);
+    /* If empty lines moved in first position, remove them */
+    while (!xbt_dynar_is_empty(a) && *xbt_dynar_getfirst_as(a, char*) == '\0')
+        xbt_dynar_shift(a, NULL);
+
+    newbuf = xbt_str_join(a, "\n");
+    strcpy(rctx->output_wanted->data, newbuf);
+    rctx->output_wanted->used = strlen(newbuf);
+    xbt_free(newbuf);
+
+    xbt_dynar_free(&a);
+  }
   xbt_strbuff_chomp(rctx->output_got);
   xbt_strbuff_chomp(rctx->output_wanted);
-  xbt_strbuff_trim(rctx->output_got);
-  xbt_strbuff_trim(rctx->output_wanted);
 
   /* Check for broken pipe */
   if (rctx->brokenpipe)
@@ -761,7 +810,7 @@ void *rctx_wait(void *r)
       XBT_INFO("<%s> No output before timeout", rctx->filepos);
     XBT_ERROR("Test suite `%s': NOK (<%s> timeout after %d sec)",
            testsuite_name, rctx->filepos, timeout_value);
-    XBT_DEBUG("<%s> Interrupted = %d", rctx->filepos, rctx->interrupted);
+    XBT_DEBUG("<%s> Interrupted = %d", rctx->filepos, (int)rctx->interrupted);
     if (!rctx->interrupted) {
       xbt_os_mutex_release(rctx->interruption);
       rctx_armageddon(rctx, 3);
@@ -811,10 +860,8 @@ void *rctx_wait(void *r)
     }
     rctx->expected_return = 0;
 
-    if (rctx->expected_signal) {
-      free(rctx->expected_signal);
-      rctx->expected_signal = NULL;
-    }
+    free(rctx->expected_signal);
+    rctx->expected_signal = NULL;
   }
 
   if ((errcode && errcode != 1) || rctx->interrupted) {
@@ -822,7 +869,7 @@ void *rctx_wait(void *r)
     xbt_dynar_t a = xbt_str_split(rctx->output_got->data, "\n");
     char *out = xbt_str_join(a, "\n||");
     xbt_dynar_free(&a);
-    XBT_INFO("Output of <%s> so far: \n||%s", rctx->filepos, out);
+    XBT_INFO("Output of <%s> so far:\n||%s", rctx->filepos, out);
     free(out);
   } else if (rctx->output == e_output_check
              && (rctx->output_got->used != rctx->output_wanted->used
@@ -844,7 +891,7 @@ void *rctx_wait(void *r)
     xbt_dynar_t a = xbt_str_split(rctx->output_got->data, "\n");
     char *out = xbt_str_join(a, "\n||");
     xbt_dynar_free(&a);
-    XBT_INFO("Here is the (ignored) command output: \n||%s", out);
+    XBT_INFO("Here is the (ignored) command output:\n||%s", out);
     free(out);
   }