Adding test for SURF concurrency feature

diff --git a/src/include/surf/maxmin.h b/src/include/surf/maxmin.h
index 6fbb863..27885bf 100644 (file)
--- a/src/include/surf/maxmin.h
+++ b/src/include/surf/maxmin.h
@@ -217,7 +217,15 @@ XBT_PUBLIC(double) lmm_constraint_get_usage(lmm_constraint_t cnst);
  */
 XBT_PUBLIC(void) lmm_constraint_concurrency_limit_set(lmm_constraint_t cnst, int concurrency_limit);
 
+/**
+ * @brief Gets the concurrency limit for this constraint
+ * 
+ * @param cnst A constraint
+ * @return The concurrency limit used by this constraint
+ */
+XBT_PUBLIC(int) lmm_constraint_concurrency_limit_get(lmm_constraint_t cnst);
 
+                            
 /**
  * @brief Reset the concurrency maximum for a given variable (we will update the maximum to reflect constraint evolution).
  *
@@ -474,6 +482,13 @@ XBT_PUBLIC(void) lmm_update_constraint_bound(lmm_system_t sys,
  */
 XBT_PUBLIC(int) lmm_constraint_used(lmm_system_t sys, lmm_constraint_t cnst);
 
+/**
+ * @brief Print the lmm system
+ * 
+ * @param sys The lmm system to print
+ */
+XBT_PUBLIC(void) lmm_print(lmm_system_t sys);
+                            
 /**
  * @brief Solve the lmm system
  * 

diff --git a/src/surf/maxmin.cpp b/src/surf/maxmin.cpp
index 70e6c56..6a98bd9 100644 (file)
--- a/src/surf/maxmin.cpp
+++ b/src/surf/maxmin.cpp
@@ -190,8 +190,14 @@ lmm_constraint_t lmm_constraint_new(lmm_system_t sys, void *id,
   return cnst;
 }
 
+int lmm_constraint_concurrency_limit_get(lmm_constraint_t cnst)
+{
+ return cnst->concurrency_limit;
+}
+
 void lmm_constraint_concurrency_limit_set(lmm_constraint_t cnst, int concurrency_limit)
 {
+  xbt_assert(concurrency_limit<0 || cnst->concurrency_maximum<=concurrency_limit,"New concurrency limit should be larger than observed concurrency maximum. Maybe you want to call  lmm_constraint_concurrency_maximum_reset() to reset the maximum?");
   cnst->concurrency_limit = concurrency_limit;
 }
 
@@ -202,6 +208,7 @@ void lmm_constraint_concurrency_maximum_reset(lmm_constraint_t cnst)
 
 int lmm_constraint_concurrency_maximum_get(lmm_constraint_t cnst)
 {
+ xbt_assert(cnst->concurrency_limit<0 || cnst->concurrency_maximum<=cnst->concurrency_limit,"Very bad: maximum observed concurrency is higher than limit. This is a bug of SURF, please report it.");
   return cnst->concurrency_maximum;
 }
 

diff --git a/src/surf/maxmin_private.hpp b/src/surf/maxmin_private.hpp
index 9de4a8a..d3ebfc3 100644 (file)
--- a/src/surf/maxmin_private.hpp
+++ b/src/surf/maxmin_private.hpp
@@ -141,7 +141,7 @@ typedef struct lmm_system {
  * 
  * @param sys A lmm system
  */
-XBT_PRIVATE void lmm_print(lmm_system_t sys);
+//XBT_PRIVATE void lmm_print(lmm_system_t sys);
 
 extern XBT_PRIVATE double (*func_f_def) (lmm_variable_t, double);
 extern XBT_PRIVATE double (*func_fp_def) (lmm_variable_t, double);

diff --git a/teshsuite/surf/maxmin_bench/maxmin_bench.c b/teshsuite/surf/maxmin_bench/maxmin_bench.c
index 35aa2e8..314fd41 100644 (file)
--- a/teshsuite/surf/maxmin_bench/maxmin_bench.c
+++ b/teshsuite/surf/maxmin_bench/maxmin_bench.c
@@ -28,23 +28,34 @@ int int_random(int max)
   return (int) (((max * 1.0) * rand()) / (RAND_MAX + 1.0));
 }
 
-void test(int nb_cnst, int nb_var, int nb_elem);
-void test(int nb_cnst, int nb_var, int nb_elem)
+void test(int nb_cnst, int nb_var, int nb_elem, int pw_base_limit, int pw_max_limit, float rate_no_limit, int max_share);
+void test(int nb_cnst, int nb_var, int nb_elem, int pw_base_limit, int pw_max_limit, float rate_no_limit, int max_share)
 {
   lmm_system_t Sys = NULL;
   lmm_constraint_t *cnst = xbt_new0(lmm_constraint_t, nb_cnst);
   lmm_variable_t *var = xbt_new0(lmm_variable_t, nb_var);
   int *used = xbt_new0(int, nb_cnst);
-  int i, j, k;
-
+  int i, j, k,l;
+  
   Sys = lmm_system_new(1);
 
   for (i = 0; i < nb_cnst; i++) {
     cnst[i] = lmm_constraint_new(Sys, NULL, float_random(10.0));
+    if(rate_no_limit>float_random(1.0))
+      //Look at what happens when there is no concurrency limit 
+      l=-1;
+    else
+      //Badly logarithmically random concurrency limit in [2^pw_base_limit+1,2^pw_base_limit+2^pw_max_limit]
+      l=(1<<pw_base_limit)+(1<<int_random(pw_max_limit));
+ 
+    lmm_constraint_concurrency_limit_set(cnst[i],l );
   }
-
+  
   for (i = 0; i < nb_var; i++) {
     var[i] = lmm_variable_new(Sys, NULL, 1.0, -1.0, nb_elem);
+    //Have a few variables with a concurrency share of two (e.g. cross-traffic in some cases)
+    lmm_variable_concurrency_share_set(var[i],1+int_random(max_share));
+      
     for (j = 0; j < nb_cnst; j++)
       used[j] = 0;
     for (j = 0; j < nb_elem; j++) {
@@ -63,24 +74,53 @@ void test(int nb_cnst, int nb_var, int nb_elem)
   lmm_solve(Sys);
   date = xbt_os_time() * 1000000 - date;
 
+  printf("Max concurrency:\n");
+  l=0;
+  for (i = 0; i < nb_cnst; i++) {
+    j=lmm_constraint_concurrency_maximum_get(cnst[i]);
+    k=lmm_constraint_concurrency_limit_get(cnst[i]);
+    xbt_assert(k<0 || j<=k);
+    if(j>l)
+      l=j;
+    printf("(%i):%i/%i ",i,j,k);
+    lmm_constraint_concurrency_maximum_reset(cnst[i]);
+    xbt_assert(!lmm_constraint_concurrency_maximum_get(cnst[i]));
+    if(i%10==9)
+       printf("\n");    
+  }
+  printf("\nTotal maximum concurrency is %i\n",l);
+
+  lmm_print(Sys);
+  
   for (i = 0; i < nb_var; i++)
     lmm_variable_free(Sys, var[i]);
   lmm_system_free(Sys);
   free(cnst);
   free(var);
   free(used);
+  
 }
 
 int main(int argc, char **argv)
 {
   int nb_cnst = 2000;
   int nb_var = 2000;
-  int nb_elem = 80;
+  int nb_elem; 
+  int pw_base_limit=5; 
+  int pw_max_limit=8;
+  float rate_no_limit=0.2;
+  int max_share=1<<(pw_base_limit/2+1);
+  
+  //If you want to test concurrency, you need nb_elem >> 2^pw_base_limit:
+  nb_elem= (1<<pw_base_limit)+(1<<(8*pw_max_limit/10));
+  //Otherwise, just set it to a constant value (and set rate_no_limit to 1.0):
+  //nb_elem=200
+  
   xbt_init(&argc, argv);
   date = xbt_os_time() * 1000000;
-  test(nb_cnst, nb_var, nb_elem);
+  test(nb_cnst, nb_var, nb_elem, pw_base_limit, pw_max_limit, rate_no_limit,max_share);    
   printf("One shot execution time for a total of %d constraints, "
-         "%d variables with %d active constraint each : %g microsecondes \n",
+         "%d variables with %d active constraint each : %g microseconds \n",
          nb_cnst, nb_var, nb_elem, date);
   return 0;
 }