Merge branch 'master' of git+ssh://git.taler.net/var/git/mint

5 files changed, 427 insertions, 310 deletions

diff --git a/src/mintdb/Makefile.am b/src/mintdb/Makefile.am
index 57aa03b93..73ecd975d 100644
--- a/src/mintdb/Makefile.am
+++ b/src/mintdb/Makefile.am
@@ -46,7 +46,8 @@ libtalermintdb_la_LDFLAGS = \
 check_PROGRAMS = \
   test-mintdb-deposits \
   test-mintdb-keyio \
-  test-mintdb-postgres
+  test-mintdb-postgres \
+	perf-mintdb
 
 TESTS = \
   test-mintdb-postgres
@@ -76,5 +77,17 @@ test_mintdb_postgres_LDADD = \
   $(top_srcdir)/src/util/libtalerutil.la \
   $(top_srcdir)/src/pq/libtalerpq.la \
   -lgnunetutil -ljansson
+
+perf_mintdb_SOURCES = \
+	perf_taler_mintdb.c \
+	perf_taler_mintdb_init.c \
+	perf_taler_mintdb_interpreter.c
+
+perf_mintdb_LDADD = \
+	libtalermintdb.la \
+  $(top_srcdir)/src/util/libtalerutil.la \
+	-lgnunetutil
+
+
 EXTRA_test_mintdb_postgres_DEPENDENCIES = \
   libtaler_plugin_mintdb_postgres.la
diff --git a/src/mintdb/perf_taler_mintdb.c b/src/mintdb/perf_taler_mintdb.c
index 832332c61..5d67b87e0 100644
--- a/src/mintdb/perf_taler_mintdb.c
+++ b/src/mintdb/perf_taler_mintdb.c
@@ -19,43 +19,42 @@
  * @author Nicolas Fournier
  */
 #include "perf_taler_mintdb_interpreter.h"
+#include "./perf_taler_mintdb_init.h"
 #include "perf_taler_mintdb_values.h"
 
 /**
  * Runs the performances tests for the mint database
+ * and logs the results using Gauger
  */
 int
-main(int argc, char ** argv)
+main (int argc, char ** argv)
 {
+  struct GNUNET_CONFIGURATION_Handle *config =
+    GNUNET_CONFIGURATION_create();
 
-  struct PERF_TALER_MINTDB_CMD test[] = 
-  {
-    INIT_CMD_LOOP("loop_db_init_deposit",100000),
-    INIT_CMD_START_TRANSACTION("start_transaction_init"),
-    INIT_CMD_INSERT_DEPOSIT("init_deposit_insert"),
-    INIT_CMD_COMMIT_TRANSACTION("commit_transaction_init"),
-    INIT_CMD_END_LOOP("endloop_init_deposit","loop_db_init_deposit"),
-
-
-    INIT_CMD_END("end")
-  };
+  GNUNET_CONFIGURATION_load(config, "./test-mint-db-postgres.conf");
 
-  struct GNUNET_CONFIGURATION_Handle config ;
-  GNUNET_CONFIGURATION_load(*config "./test-mint-db-postgres.conf");
-
-  struct TALER_MINTDB_Plugin *plugin = TALER_MINTDB_plugin_load(&config);
-  struct TALER_MINTDB_Session *session = plugin->get_session(plugin->cls, GNUNET_YES);
-  
+  struct TALER_MINTDB_Plugin *plugin = TALER_MINTDB_plugin_load (config);
+  GNUNET_CONFIGURATION_destroy(config);
+ 
   // creation of temporary tables
-  plugin->create_tables(plugin->cls, GNUNET_YES);
+  plugin->create_tables (plugin->cls, GNUNET_YES);
+
 
+  struct PERF_TALER_MINTDB_Cmd test[] = 
+  {
+    PERF_TALER_MINTDB_INIT_CMD_LOOP ("loop_db_init_deposit",100000),
+    PERF_TALER_MINTDB_INIT_CMD_START_TRANSACTION ("start_transaction_init"),
+    PERF_TALER_MINTDB_INIT_CMD_INSERT_DEPOSIT ("init_deposit_insert"),
+    PERF_TALER_MINTDB_INIT_CMD_COMMIT_TRANSACTION ("commit_transaction_init"),
+    PERF_TALER_MINTDB_INIT_CMD_END_LOOP ("endloop_init_deposit","loop_db_init_deposit"),
 
-  PERF_TALER_MINTDB_interpret(plugin, session, test);
 
+    PERF_TALER_MINTDB_INIT_CMD_END("end")
+  };
 
-  plugin->drop_temporary(plugin->cls, session);
+  PERF_TALER_MINTDB_interpret(plugin, test);
 
-  // Free the session ??
 
   TALER_MINTDB_plugin_unload(plugin);
   return GNUNET_OK;
diff --git a/src/mintdb/perf_taler_mintdb_init.c b/src/mintdb/perf_taler_mintdb_init.c
index 227d5de6a..75ebac32d 100644
--- a/src/mintdb/perf_taler_mintdb_init.c
+++ b/src/mintdb/perf_taler_mintdb_init.c
@@ -29,7 +29,9 @@
 #define CURRENCY "EUR"
 
 
-
+/**
+ * @return a randomly generated CollectableBlindcoin
+ */
 struct TALER_MINTDB_CollectableBlindcoin *
 collectable_blindcoin_init ()
 {
@@ -39,29 +41,29 @@ collectable_blindcoin_init ()
 
   struct GNUNET_CRYPTO_EddsaPrivateKey *reserve_sig_key;
   GNUNET_assert (NULL != 
-      (reserve_sig_key = GNUNET_CRYPTO_eddsa_key_create ())
-      );
+    (reserve_sig_key = GNUNET_CRYPTO_eddsa_key_create ())
+    );
 
   struct GNUNET_CRYPTO_rsa_PrivateKey  *denomination_key ;
   GNUNET_assert (NULL != 
-     (denomination_key = GNUNET_CRYPTO_rsa_private_key_create (512))
-     );
+    (denomination_key = GNUNET_CRYPTO_rsa_private_key_create (512))
+    );
 
   GNUNET_assert (NULL ==
-   (coin->denom_pub.rsa_public_key = 
-    GNUNET_CRYPTO_rsa_private_key_get_public (denomination_key))
+    (coin->denom_pub.rsa_public_key = 
+     GNUNET_CRYPTO_rsa_private_key_get_public (denomination_key))
     );
 
   GNUNET_CRYPTO_eddsa_key_get_public (reserve_sig_key,
-                                      &coin->reserve_pub.eddsa_pub);
+    &coin->reserve_pub.eddsa_pub);
 
   GNUNET_assert (GNUNET_OK ==
-      TALER_string_to_amount (CURRENCY ":1.1",
-                              &coin->amount_with_fee));
+    TALER_string_to_amount (CURRENCY ":1.1",
+      &coin->amount_with_fee));
 
   GNUNET_assert (GNUNET_OK ==
-      TALER_string_to_amount (CURRENCY ":1.1",
-                              &coin->withdraw_fee));
+    TALER_string_to_amount (CURRENCY ":1.1",
+      &coin->withdraw_fee));
 
 
 
@@ -69,14 +71,14 @@ collectable_blindcoin_init ()
     GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
   GNUNET_assert (NULL !=
     (coin->sig.rsa_signature = 
-    GNUNET_CRYPTO_rsa_sign (denomination_key, 
-                            &random_int, 
-                            sizeof (random_int)
-                            ))
+     GNUNET_CRYPTO_rsa_sign (denomination_key, 
+       &random_int, 
+       sizeof (random_int)
+       ))
     );
 
   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, 
-                                    &coin->h_coin_envelope);
+    &coin->h_coin_envelope);
 
   struct {
     struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
@@ -105,6 +107,8 @@ collectable_blindcoin_init ()
 int
 collectable_blindcoin_free (struct TALER_MINTDB_CollectableBlindcoin *coin)
 {
+  if (NULL == coin)
+    return GNUNET_OK;
   GNUNET_CRYPTO_rsa_signature_free (coin->sig.rsa_signature);
   GNUNET_CRYPTO_rsa_public_key_free (coin->denom_pub.rsa_public_key);
 
@@ -121,7 +125,7 @@ struct TALER_MINTDB_Reserve *
 reserve_init ()
 {
   struct TALER_MINTDB_Reserve *reserve ;
-  
+
   GNUNET_assert (NULL != 
     (reserve = GNUNET_new (struct TALER_MINTDB_Reserve)
     ));
@@ -133,11 +137,11 @@ reserve_init ()
     ));
 
   GNUNET_CRYPTO_eddsa_key_get_public (reserve_priv , 
-                                     &reserve->pub.eddsa_pub);
-  
+    &reserve->pub.eddsa_pub);
+
   GNUNET_assert (GNUNET_OK == 
-      TALER_string_to_amount (CURRENCY ":1.1", &reserve->balance)
-      );
+    TALER_string_to_amount (CURRENCY ":1.1", &reserve->balance)
+    );
 
   reserve->expiry = GNUNET_TIME_absolute_get_forever_ ();
 
@@ -145,11 +149,14 @@ reserve_init ()
   return reserve;
 }
 
+
+/**
+ * Free memory of a reserve
+ */
 int
 reserve_free (struct TALER_MINTDB_Reserve *reserve)
 {
   GNUNET_free (reserve);
-
   return GNUNET_OK;
 }
 
@@ -180,7 +187,6 @@ int
 refresh_session_free (struct TALER_MINTDB_RefreshSession *refresh_session)
 {
   GNUNET_free (refresh_session);
-
   return GNUNET_OK;
 }
 
@@ -199,14 +205,13 @@ deposit_init ()
     ));
 
   deposit-> transaction_id = transaction_id;
-  transaction_id++;
 
   GNUNET_assert (GNUNET_OK == 
-      TALER_string_to_amount (CURRENCY ":1.1", &deposit->amount_with_fee)
-      );
+    TALER_string_to_amount (CURRENCY ":1.1", &deposit->amount_with_fee)
+    );
 
   GNUNET_assert (GNUNET_OK == 
-      TALER_string_to_amount (CURRENCY ":0.1", &deposit->deposit_fee)
+    TALER_string_to_amount (CURRENCY ":0.1", &deposit->deposit_fee)
     );
 
 
@@ -214,9 +219,9 @@ deposit_init ()
   deposit->refund_deadline = GNUNET_TIME_absolute_get ();
 
   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, 
-                                    &deposit->h_contract);
+    &deposit->h_contract);
   GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, 
-                                    &deposit->h_wire);
+    &deposit->h_wire);
 
   // Coin Spend Signature
   {
@@ -233,9 +238,10 @@ deposit_init ()
 
     uint32_t random_int = 
       GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX);
- 
-    
+
+
     unsigned_data.purpose.size = sizeof (unsigned_data);
+
     unsigned_data.purpose.purpose = GNUNET_SIGNATURE_PURPOSE_TEST;
     unsigned_data.data = random_int;
 
@@ -244,10 +250,11 @@ deposit_init ()
         (struct GNUNET_CRYPTO_EccSignaturePurpose *) &unsigned_data, 
         &deposit->csig.eddsa_signature)
       );
-
+    
     GNUNET_CRYPTO_eddsa_key_clear (eddsa_prvt);
   }
 
+  printf("coin signed");
   // Merchant Key
   {
     struct GNUNET_CRYPTO_EddsaPrivateKey *eddsa_prv; 
@@ -256,13 +263,14 @@ deposit_init ()
       ));
 
     GNUNET_CRYPTO_eddsa_key_get_public (
-        eddsa_prv, 
-        &deposit->merchant_pub.eddsa_pub);
+      eddsa_prv, 
+      &deposit->merchant_pub.eddsa_pub);
 
 
     GNUNET_CRYPTO_eddsa_key_clear (eddsa_prv);
   }
-
+  
+  printf("merchant ok");
   // Coin
   {
     {
@@ -282,22 +290,22 @@ deposit_init ()
 
     {
       struct GNUNET_CRYPTO_rsa_PrivateKey *rsa_prv;
-     GNUNET_assert (NULL !=
+      GNUNET_assert (NULL !=
         (rsa_prv = GNUNET_CRYPTO_rsa_private_key_create (128)
         ));
 
-     GNUNET_assert (NULL !=
-       (deposit->coin.denom_pub.rsa_public_key =
-       GNUNET_CRYPTO_rsa_private_key_get_public (rsa_prv)
-       ));
+      GNUNET_assert (NULL !=
+        (deposit->coin.denom_pub.rsa_public_key =
+         GNUNET_CRYPTO_rsa_private_key_get_public (rsa_prv)
+        ));
 
-     GNUNET_assert (NULL !=
-       (deposit->coin.denom_sig.rsa_signature = 
-       GNUNET_CRYPTO_rsa_sign (rsa_prv,
+      GNUNET_assert (NULL !=
+        (deposit->coin.denom_sig.rsa_signature = 
+         GNUNET_CRYPTO_rsa_sign (rsa_prv,
            (void *) &deposit->coin.coin_pub.eddsa_pub,
            sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)
            )
-       ));
+        ));
 
       GNUNET_CRYPTO_rsa_private_key_free (rsa_prv);
     }
@@ -312,6 +320,8 @@ deposit_init ()
 int
 deposit_free (struct TALER_MINTDB_Deposit *deposit)
 {
+  if ( NULL == deposit)
+    return GNUNET_OK;
   GNUNET_CRYPTO_rsa_public_key_free (deposit->coin.denom_pub.rsa_public_key);
   GNUNET_CRYPTO_rsa_signature_free (deposit->coin.denom_sig.rsa_signature);
 
@@ -338,11 +348,11 @@ denomination_init ()
 
   GNUNET_assert (NULL !=
     (dki->denom_priv.rsa_private_key
-    = GNUNET_CRYPTO_rsa_private_key_create (128)
+     = GNUNET_CRYPTO_rsa_private_key_create (128)
     ));
   GNUNET_assert (NULL !=
     (dki->denom_pub.rsa_public_key =
-    GNUNET_CRYPTO_rsa_private_key_get_public (dki->denom_priv.rsa_private_key)
+     GNUNET_CRYPTO_rsa_private_key_get_public (dki->denom_priv.rsa_private_key)
     ));
 
   GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub.rsa_public_key,
@@ -354,20 +364,20 @@ denomination_init ()
 
 
   GNUNET_CRYPTO_eddsa_key_get_public (master_prvt,
-                                      &dki->issue.master.eddsa_pub); 
+    &dki->issue.master.eddsa_pub); 
 
   anchor = GNUNET_TIME_absolute_get ();
 
   dki->issue.start = GNUNET_TIME_absolute_hton (anchor);
   dki->issue.expire_withdraw =
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
-          GNUNET_TIME_relative_get_hour_ ()));
+        GNUNET_TIME_relative_get_hour_ ()));
   dki->issue.expire_spend =
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
-          GNUNET_TIME_relative_get_hour_ ()));
+        GNUNET_TIME_relative_get_hour_ ()));
   dki->issue.expire_legal =
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
-          GNUNET_TIME_relative_get_hour_ ()));
+        GNUNET_TIME_relative_get_hour_ ()));
 
   GNUNET_assert (GNUNET_OK ==
     TALER_string_to_amount (CURRENCY ":1.1", &amount)
@@ -380,8 +390,8 @@ denomination_init ()
   dki->issue.purpose.purpose = htonl (TALER_SIGNATURE_MASTER_DENOMINATION_KEY_VALIDITY);
   dki->issue.purpose.size = 
     htonl (sizeof (struct TALER_MINTDB_DenominationKeyIssueInformation) -
-           offsetof (struct TALER_MINTDB_DenominationKeyIssueInformation,
-          issue.purpose));
+      offsetof (struct TALER_MINTDB_DenominationKeyIssueInformation,
+        issue.purpose));
   GNUNET_assert (GNUNET_OK ==
     GNUNET_CRYPTO_eddsa_sign (master_prvt,
       &dki->issue.purpose,
@@ -392,12 +402,15 @@ denomination_init ()
   return dki;
 }
 
+
 /**
  * Free memory for a DenominationKeyIssueInformation
  */
 int
 denomination_free (struct TALER_MINTDB_DenominationKeyIssueInformation *dki)
 {
+  if (NULL ==dki)
+    return GNUNET_OK;
   GNUNET_CRYPTO_rsa_private_key_free (dki->denom_priv.rsa_private_key);
   GNUNET_CRYPTO_rsa_public_key_free (dki->denom_pub.rsa_public_key);
 
diff --git a/src/mintdb/perf_taler_mintdb_interpreter.c b/src/mintdb/perf_taler_mintdb_interpreter.c
index ea38abe5b..fdfc6e9e8 100644
--- a/src/mintdb/perf_taler_mintdb_interpreter.c
+++ b/src/mintdb/perf_taler_mintdb_interpreter.c
@@ -24,13 +24,58 @@
 
 
 /**
+ * Represents the state of the interpreter
+ */
+struct PERF_TALER_MINTDB_interpreter_state
+{
+  /**
+   * State of the commands
+   */
+  struct PERF_TALER_MINTDB_Cmd *cmd;
+
+  /**
+   * Database plugin
+   */
+  struct TALER_MINTDB_Plugin *plugin;
+
+  /**
+   * Current database session
+   */
+  struct TALER_MINTDB_Session *session;
+
+  /**
+   * The current index of the interpreter
+   */
+  int i;
+};
+
+/**
+ * Free the memory of @a data, with data of type @a type
+ */
+static void
+data_free (union PERF_TALER_MINTDB_Data *data, enum PERF_TALER_MINTDB_Type type){
+  switch (type)
+  {
+    case PERF_TALER_MINTDB_DEPOSIT:
+      deposit_free (data->deposit);
+      data->deposit = NULL;
+      return;
+
+    default:
+      return;
+  }
+} 
+
+
+
+/**
  * Finds the first command in cmd with the name search
  *
  * @return the index of the first command with name search
  * GNUNET_SYSERR if none found
  */
 static int
-cmd_find(const struct  PERF_TALER_MINTDB_Cmd *cmd, const char *search)
+cmd_find (const struct  PERF_TALER_MINTDB_Cmd *cmd, const char *search)
 {
   int i;
 
@@ -41,9 +86,11 @@ cmd_find(const struct  PERF_TALER_MINTDB_Cmd *cmd, const char *search)
 }
 
 
-// Initialization of a command array
+/**
+ * Initialization of a command array      
+ */
 static int
-cmd_init(struct PERF_TALER_MINTDB_Cmd cmd[])
+cmd_init (struct PERF_TALER_MINTDB_Cmd cmd[])
 {
   int i = 0;
   for (i=0; PERF_TALER_MINTDB_CMD_END != cmd[i].command; i++)
@@ -61,8 +108,8 @@ cmd_init(struct PERF_TALER_MINTDB_Cmd cmd[])
         // Creating the permutation array to randomize the data order
         cmd[i].details.load_array.permutation =
           GNUNET_CRYPTO_random_permute (
-                                        GNUNET_CRYPTO_QUALITY_WEAK,
-                                        cmd[i].details.load_array.nb);
+            GNUNET_CRYPTO_QUALITY_WEAK,
+            cmd[cmd_find(cmd, cmd[i].details.load_array.label_save)].details.save_array.nb_saved);
 
         // Initializing the type based on the type of the saved array
         cmd[i].exposed_type = cmd[
@@ -85,27 +132,20 @@ static int
 cmd_clean (struct PERF_TALER_MINTDB_Cmd cmd[])
 {
   int i = 0;
-  for(i=0; PERF_TALER_MINTDB_CMD_END != cmd[i].command; i++)
+  for (i=0; PERF_TALER_MINTDB_CMD_END != cmd[i].command; i++)
   {
     switch (cmd[i].command)
     {
       case PERF_TALER_MINTDB_CMD_SAVE_ARRAY:
         {
           int j;
-          switch (cmd[i].details.save_array.type_saved)
+          for (j = 0; j < cmd[i].details.save_array.nb_saved; j++)
           {
-            case PERF_TALER_MINTDB_DEPOSIT:
-              for (j = 0; j < cmd[i].details.save_array.nb_saved; j++)
-              {
-                deposit_free (cmd[i].details.save_array.data_saved[j].deposit);
-                cmd[i].details.save_array.data_saved[j].deposit = NULL;
-              }
-              GNUNET_free (cmd[i].details.save_array.data_saved);
-              break;
-
-            default:
-              break;
+            data_free (&cmd[i].details.save_array.data_saved[j],
+              cmd[i].details.save_array.type_saved);
           }
+
+          GNUNET_free (cmd[i].details.save_array.data_saved);
           cmd[i].details.save_array.data_saved = NULL;
         }
 
@@ -128,175 +168,191 @@ cmd_clean (struct PERF_TALER_MINTDB_Cmd cmd[])
 
 
 /**
+ * Handles the command END_LOOP for the interpreter
+ */
+static void
+interpret_end_loop (struct PERF_TALER_MINTDB_interpreter_state *state)
+{
+  int jump = cmd_find (state->cmd, state->cmd[state->i].details.end_loop.label_loop);
+  // If the loop is not finished
+  if (state->cmd[jump].details.loop.max_iterations > state->cmd[jump].details.loop.curr_iteration)
+  {
+    // jump back to the start
+    state->i = jump -1;
+  }else{
+    // Reset the loop counter and continue running
+    state->cmd[jump].details.loop.curr_iteration = -1;
+  }
+  // Cleaning up the memory in the loop
+  int j;
+  for (j = jump; j < state->i; j++)
+  {
+    // If the exposed variable has not been copied
+    if ( 0 == state->cmd[j].exposed_saved)
+    {
+      // It is freed
+      data_free (&state->cmd[j].exposed, state->cmd[j].exposed_type);
+    }
+    state->cmd[j].exposed_saved = 0;
+  }
+}
+
+
+
+/**
  * /TODO cut it into pieces
  */
 static int
-interpret(struct TALER_MINTDB_Plugin *db_plugin,
-          struct TALER_MINTDB_Session*session,
-          struct PERF_TALER_MINTDB_Cmd cmd[])
+interpret (struct PERF_TALER_MINTDB_interpreter_state *state)
 {
-  int i=0;
-  for(i=0; PERF_TALER_MINTDB_CMD_END == cmd[i].command; i++)
+
+  for (state->i=0; PERF_TALER_MINTDB_CMD_END != state->cmd[state->i].command; state->i++)
   {
-    switch (cmd[i].command)
+    switch (state->cmd[state->i].command)
     {
       case PERF_TALER_MINTDB_CMD_END:
         return GNUNET_YES;
 
       case PERF_TALER_MINTDB_CMD_LOOP:
-        cmd[i].details.loop.curr_iteration++;
+        state->cmd[state->i].details.loop.curr_iteration++;
         break;
 
       case PERF_TALER_MINTDB_CMD_END_LOOP:
-        {
-          int jump = cmd_find(cmd, cmd[i].details.end_loop.label_loop);
-          if (cmd[jump].details.loop.max_iterations > cmd[jump].details.loop.curr_iteration)
-          {
-            i = jump -1;
-          }else{
-            // Reseting loop counter
-            cmd[jump].details.loop.curr_iteration = -1;
-          }
-          // Cleaning up the memory in the loop
-          int j;
-          // For each command in the loop
-          for (j = jump; j < i; j++)
-          {
-            // If the exposed variable has not been copied
-            if ( 0 == cmd[j].exposed_saved)
-            {
-              // It is freed
-              switch (cmd[j].exposed_type)
-              {
-                case PERF_TALER_MINTDB_DEPOSIT:
-                  deposit_free (cmd[j].exposed.deposit);
-                  cmd[j].exposed.deposit = NULL;
-                  break;
-
-                default:
-                  break;
-              }
-            }
-            cmd[j].exposed_saved = 0;
-          }
-        }
+        interpret_end_loop (state);
         break;
 
-
       case PERF_TALER_MINTDB_CMD_GET_TIME:
-        clock_gettime(CLOCK_MONOTONIC, &cmd[i].exposed.time);
+        clock_gettime (CLOCK_MONOTONIC, &state->cmd[state->i].exposed.time);
         break;
 
-
       case PERF_TALER_MINTDB_CMD_GAUGER:
         {
-          int start_index = cmd_find (cmd, cmd[i].details.gauger.label_start);
-          int stop_index  = cmd_find (cmd, cmd[i].details.gauger.label_stop);
-          struct timespec start = cmd [start_index].exposed.time;
-          struct timespec stop = cmd [stop_index].exposed.time;
+          int start_index = cmd_find (state->cmd, state->cmd[state->i].details.gauger.label_start);
+          int stop_index  = cmd_find (state->cmd, state->cmd[state->i].details.gauger.label_stop);
+          struct timespec start = state->cmd [start_index].exposed.time;
+          struct timespec stop = state->cmd [stop_index].exposed.time;
 
           unsigned long elapsed_ms = (start.tv_sec - stop.tv_sec) * 1000 + (start.tv_nsec - stop.tv_nsec) / 1000000;
 
-          GAUGER ("MINTDB", cmd[i].details.gauger.description, elapsed_ms, "milliseconds");
+          GAUGER ("MINTDB", state->cmd[state->i].details.gauger.description, elapsed_ms, "milliseconds");
         }
         break;
 
-      case PERF_TALER_MINTDB_CMD_START_TRANSACTION:
-        db_plugin->start(db_plugin->cls, session);
+      case PERF_TALER_MINTDB_CMD_NEW_SESSION:
+        state->session = state->plugin->get_session (state->plugin->cls, GNUNET_YES);
+        // TODO what about the old session ?
         break;
 
-
-      case PERF_TALER_MINTDB_CMD_COMMIT_TRANSACTION:
-        db_plugin->commit(db_plugin->cls, session);
-        break;
-
-
-      case PERF_TALER_MINTDB_CMD_INSERT_DEPOSIT:
-        {
-          struct TALER_MINTDB_Deposit *deposit = deposit_init (-1);
-          db_plugin->insert_deposit(db_plugin->cls, session, deposit);
-
-          cmd[i].exposed.deposit = deposit;
-        }
+      case PERF_TALER_MINTDB_CMD_START_TRANSACTION:
+        state->plugin->start (state->plugin->cls, state->session);
         break;
 
-
-      case PERF_TALER_MINTDB_CMD_GET_DEPOSIT:
-        {
-          int source_index = cmd_find(cmd, cmd[i].details.get_deposit.source); // Find the source location
-          struct TALER_MINTDB_Deposit *deposit = cmd[source_index].exposed.deposit; // Get the deposit from the source
-          db_plugin->have_deposit(db_plugin->cls, session, deposit);
-        }
+      case PERF_TALER_MINTDB_CMD_COMMIT_TRANSACTION:
+        state->plugin->commit (state->plugin->cls, state->session);
         break;
 
+      case PERF_TALER_MINTDB_CMD_ABORT_TRANSACTION:
+        state->plugin->rollback (state->plugin->cls, state->session);
 
       case PERF_TALER_MINTDB_CMD_SAVE_ARRAY:
         {
           // Array initialization on first loop iteration
           // Alows for nested loops
-          if (cmd[cmd_find(cmd, cmd[i].details.save_array.label_loop)].details.loop.curr_iteration == 0)
+          if (state->cmd[cmd_find (state->cmd, state->cmd[state->i].details.save_array.label_loop)].details.loop.curr_iteration == 0)
           {
-            cmd[i].details.save_array.index = 0;
+            state->cmd[state->i].details.save_array.index = 0;
           }
 
-          int loop_index = cmd_find(cmd, cmd[i].details.save_array.label_loop);
-          int proba = cmd[loop_index].details.loop.max_iterations / cmd[i].details.save_array.nb_saved;
-          int rnd = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, proba);
-
-          // If there is a lesser or equal number of iteration next than room remain in the array
-          if ((cmd[loop_index].details.loop.max_iterations - cmd[loop_index].details.loop.curr_iteration <=
-               cmd[i].details.save_array.nb_saved - cmd[i].details.save_array.index) ||
-              (rnd == 0 && cmd[i].details.save_array.index < cmd[i].details.save_array.nb_saved))
+          // TODO check the logic here. It probably can be improved
+          
+          int loop_index = cmd_find (state->cmd, state->cmd[state->i].details.save_array.label_loop);
+          int proba = state->cmd[loop_index].details.loop.max_iterations / state->cmd[state->i].details.save_array.nb_saved;
+          int rnd = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, proba);
+
+
+          /**
+           * If the room available is equal to the remaining number of
+           * iterations, the item is automaticly saved.
+           *
+           * Else it is saved only if rdn is 0
+           */
+          if ((state->cmd[loop_index].details.loop.max_iterations - state->cmd[loop_index].details.loop.curr_iteration ==
+              state->cmd[state->i].details.save_array.nb_saved - state->cmd[state->i].details.save_array.index) ||
+            (rnd == 0))
           {
-            // We automaticly save the whatever we need to
-            switch (cmd[i].details.save_array.type_saved)
+
+            union PERF_TALER_MINTDB_Data *save_location =
+              &state->cmd[state->i].details.save_array.data_saved[state->cmd[state->i].details.save_array.index];
+            union PERF_TALER_MINTDB_Data *item_saved =
+              &state->cmd[cmd_find (state->cmd, state->cmd[state->i].details.save_array.label_save)].exposed;
+
+
+            switch (state->cmd[state->i].details.save_array.type_saved)
             {
               case PERF_TALER_MINTDB_DEPOSIT:
-                cmd[i].details.save_array.data_saved[cmd[i].details.save_array.index].deposit =
-                  cmd[cmd_find (cmd, cmd[i].details.save_array.label_save)].exposed.deposit;
+                save_location->deposit = item_saved->deposit;
                 break;
 
               case PERF_TALER_MINTDB_TIME:
-                cmd[i].details.save_array.data_saved[cmd[i].details.save_array.index].time =
-                  cmd[cmd_find (cmd, cmd[i].details.save_array.label_save)].exposed.time;
+                save_location->time = item_saved->time;
                 break;
 
               default:
                 break;
             }
-            cmd[cmd_find (cmd, cmd[i].details.save_array.label_save)].exposed_saved = 1;
-            cmd[i].details.save_array.index++;
+            state->cmd[state->i].details.save_array.index++;
           }
         }
         break;
 
-
       case PERF_TALER_MINTDB_CMD_LOAD_ARRAY:
         {
+          int loop_index = cmd_find (state->cmd, state->cmd[state->i].details.load_array.label_loop);
+          int save_index = cmd_find (state->cmd, state->cmd[state->i].details.load_array.label_save);
+
+          /* Extracting the data from the loop_indexth indice in save_index
+           * array.
+           */
+          union PERF_TALER_MINTDB_Data loaded_data =
+            state->cmd[save_index].details.save_array.data_saved[
+            state->cmd[state->i].details.load_array.permutation[
+              state->cmd[loop_index].details.loop.curr_iteration
+            ]];
+
 
-          int loop_index = cmd_find(cmd, cmd[i].details.load_array.label_loop);
-          int save_index = cmd_find(cmd, cmd[i].details.load_array.label_save);
-          switch (cmd[i].exposed_type){
+          switch (state->cmd[state->i].exposed_type)
+          {
             case PERF_TALER_MINTDB_DEPOSIT:
-              cmd[i].exposed.deposit = cmd[save_index].details.save_array.data_saved[
-                cmd[i].details.load_array.permutation[
-                  cmd[loop_index].details.loop.curr_iteration
-                ]
-              ].deposit;
-                break;
+              state->cmd[state->i].exposed.deposit = loaded_data.deposit;
+              break;
 
             case PERF_TALER_MINTDB_TIME:
-                cmd[i].exposed.time = cmd[save_index].details.save_array.data_saved[
-                  cmd[i].details.load_array.permutation[
-                    cmd[loop_index].details.loop.curr_iteration
-                  ]
-                ].time;
-                  break;
+              state->cmd[state->i].exposed.time = loaded_data.time;
+              break;
 
             default:
-                  break;
+              break;
           }
         }
+        break;
+
+      case PERF_TALER_MINTDB_CMD_INSERT_DEPOSIT:
+        {
+          struct TALER_MINTDB_Deposit *deposit = deposit_init (-1);
+          state->plugin->insert_deposit (state->plugin->cls, state->session, deposit);
+
+          state->cmd[state->i].exposed.deposit = deposit;
+        }
+        break;
+
+      case PERF_TALER_MINTDB_CMD_GET_DEPOSIT:
+        {
+          int source_index = cmd_find (state->cmd, state->cmd[state->i].details.get_deposit.label_source); // Find the source location
+          struct TALER_MINTDB_Deposit *deposit = state->cmd[source_index].exposed.deposit; // Get the deposit from the source
+          state->plugin->have_deposit (state->plugin->cls, state->session, deposit);
+        }
+        break;
+
       default :
         break;
     }
@@ -304,23 +360,27 @@ interpret(struct TALER_MINTDB_Plugin *db_plugin,
   return GNUNET_OK;
 }
 
+
 /**
  * Runs the commands given in @a cmd, working with
  * the database referenced by @a db_plugin
  */
 int
-PERF_TALER_MINTDB_interpret(struct TALER_MINTDB_Plugin *db_plugin,
-                            struct TALER_MINTDB_Session *session,
-                            struct PERF_TALER_MINTDB_Cmd cmd[])
+PERF_TALER_MINTDB_interpret (struct TALER_MINTDB_Plugin *db_plugin,
+  struct PERF_TALER_MINTDB_Cmd cmd[])
 {
   // Initializing commands
-  cmd_init(cmd);
+  cmd_init (cmd);
 
   // Running the interpreter
-  interpret(db_plugin, session, cmd);
+  struct PERF_TALER_MINTDB_interpreter_state state = 
+  {.i = 0, .cmd = cmd, .plugin = db_plugin};
+  state.session = db_plugin->get_session (db_plugin->cls, GNUNET_YES);
+
+  interpret (&state);
 
   // Cleaning the memory
-  cmd_clean(cmd);
+  cmd_clean (cmd);
 
   return GNUNET_YES;
 }
diff --git a/src/mintdb/perf_taler_mintdb_interpreter.h b/src/mintdb/perf_taler_mintdb_interpreter.h
index cf2ca664f..12dec6d84 100644
--- a/src/mintdb/perf_taler_mintdb_interpreter.h
+++ b/src/mintdb/perf_taler_mintdb_interpreter.h
@@ -31,139 +31,143 @@
  * Marks the end of the command chain
  * @param _label
  */
-#define INIT_CMD_END(label) {.command = PERF_TALER_MINTDB_CMD_END, .label = _label}
+#define PERF_TALER_MINTDB_INIT_CMD_END(_label) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_END, \
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE \
+}
 
 /**
  * The begining of a loop
  * @param _label the name of the loop
  * @param _iter the number of iteration of the loop
  */
-#define INIT_CMD_LOOP(_label, _iter) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_LOOP, \
-    .label = _label, \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-    .details.loop = { \
-       .max_iterations = _iter, \
-       .curr_iteration = -1} \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_LOOP(_label, _iter) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_LOOP , \
+  .label = _label , \
+  .exposed_type = PERF_TALER_MINTDB_NONE , \
+  .details.loop = { \
+    .max_iterations = _iter , \
+    .curr_iteration = -1} \
+}
 
 /**
  * Marks the end of the loop @_label_loop
  */
-#define INIT_CMD_END_LOOP(_label, _label_loop) \
-  {\
-    .command = PERF_TALER_MINTDB_CMD_END_LOOP,\
-    .label = _label,\
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-    .details.end_loop.label_loop = _label_loop \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_END_LOOP(_label, _label_loop) \
+{\
+  .command = PERF_TALER_MINTDB_CMD_END_LOOP , \
+  .label = _label , \
+  .exposed_type = PERF_TALER_MINTDB_NONE , \
+  .details.end_loop.label_loop = _label_loop \
+}
 
 /**
  * Saves the time of execution to use for logging with gauger
  */
-#define INIT_CMD_GET_TIME(_label) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_GET_TIME, \
-    .label = _label \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_GET_TIME(_label) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_GET_TIME, \
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE, \
+}
 
 /**
  * Commits the duration between @a _label_start and @a _label_stop
  * to Gauger with @a _description explaining
  */
-#define INIT_CMD_GAUGER(_label, _start_time, _stop_time, _description) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_GAUGER, \
-    .label = _label, \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-    .details.gauger = { \
-         .label_start = _label_start, \
-         .label_end = _label_end, \
-         .description = _description \
-    } \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_GAUGER(_label, _start_time, _stop_time, _description) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_GAUGER, \
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE, \
+  .details.gauger = { \
+    .label_start = _label_start, \
+    .label_end = _label_end, \
+    .description = _description \
+  } \
+}
 
 /**
  * Initiate a database transaction
  */
-#define INIT_CMD_START_TRANSACTION(_label) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_START_TRANSACTION, \
-    .label = _label \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_START_TRANSACTION(_label) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_START_TRANSACTION, \
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE, \
+}
 
 /**
  * Commits a database connection
  */
-#define INIT_CMD_COMMIT_TRANSACTION(_label) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_COMMIT_TRANSACTION, \
-    .label = _label \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_COMMIT_TRANSACTION(_label) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_COMMIT_TRANSACTION, \
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE, \
+}
 
 /**
  * Insert a deposit into the database
  */
-#define INIT_CMD_INSERT_DEPOSIT(_label) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_INSERT_DEPOSIT,\
-    .label = label \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_INSERT_DEPOSIT(_label) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_INSERT_DEPOSIT,\
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE, \
+}
 
 /**
  * Check if a deposit is in the database
  * @param _label_deposit Label of the deposit to use
  */
-#define INIT_CMD_GET_DEPOSIT(_label, _label_deposit) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_GET_DEPOSIT, \
-    .label = _label, \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-    .details.label_deposit.saved = _label_deposit \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_GET_DEPOSIT(_label, _label_deposit) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_GET_DEPOSIT, \
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE, \
+  .details.label_deposit.saved = _label_deposit \
+}
 
 /**
  * Extracts @a _nb_saved items of type @a _save_type 
  * from the command @a _label_save during the loop @a _label_loop
  */
-#define INIT_CMD_SAMPLE_ARRAY(_label, _label_loop, _label_save, _nb_saved, _save_type) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_SAVE_ARRAY, \
-    .label = _label, \
-    .exposed_type = PERF_TALER_MINTDB_NONE, \
-    .details.save_array = { \
-        .label_loop = _label_loop, \
-        .label_save = _label_save, \
-        .nb_saved = _nb_saved, \
-        .save_type = _save_type \
-      } \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_SAMPLE_ARRAY(_label, _label_loop, _label_save, _nb_saved, _save_type) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_SAVE_ARRAY, \
+  .label = _label, \
+  .exposed_type = PERF_TALER_MINTDB_NONE, \
+  .details.save_array = { \
+    .label_loop = _label_loop, \
+    .label_save = _label_save, \
+    .nb_saved = _nb_saved, \
+    .save_type = _save_type \
+  } \
+}
 
 /**
  * Loads @a _nb_saved previously sampled data of type @a _saved_type
  * from @a _label_save during the loop @a _label_loop 
  */
-#define INIT_CMD_LOAD_ARRAY(_label, _label_loop, _label_save, _nb_saved, _save_type) \
-  { \
-    .command = PERF_TALER_MINTDB_CMD_LOAD_ARRAY, \
-    .label = _label, \
-    .exposed_type = _saved_type_, \
-    .details.load_array = { \
-      .label_loop = _label_loop, \
-      .label_save = _label_save \
-      .nb_saved = _nb_saved, \
-     } \
-  }
+#define PERF_TALER_MINTDB_INIT_CMD_LOAD_ARRAY(_label, _label_loop, _label_save) \
+{ \
+  .command = PERF_TALER_MINTDB_CMD_LOAD_ARRAY, \
+  .label = _label, \
+  .details.load_array = { \
+    .label_loop = _label_loop, \
+    .label_save = _label_save \
+  } \
+}
 
 
 
 /**
  * The type of data stored
+ * in a PERF_TALER_MINTDB_Type
  */
 enum PERF_TALER_MINTDB_Type 
 {
@@ -203,12 +207,18 @@ enum PERF_TALER_MINTDB_CMD_Name
   // Upload performance to Gauger
   PERF_TALER_MINTDB_CMD_GAUGER,
 
+  // Start a new session
+  PERF_TALER_MINTDB_CMD_NEW_SESSION,
+
   // Start a database transaction
   PERF_TALER_MINTDB_CMD_START_TRANSACTION,
 
   // End a database transaction
   PERF_TALER_MINTDB_CMD_COMMIT_TRANSACTION,
 
+  // Abort a transaction
+  PERF_TALER_MINTDB_CMD_ABORT_TRANSACTION,
+
   // Insert a deposit into the database
   PERF_TALER_MINTDB_CMD_INSERT_DEPOSIT,
 
@@ -224,7 +234,10 @@ enum PERF_TALER_MINTDB_CMD_Name
 } command;
 
 
-struct PERF_TALER_MINTDB_loop_details
+/**
+ * Extra data requiered for the LOOP command
+ */
+struct PERF_TALER_MINTDB_CMD_loop_details
 {
   // Maximum number of iteration in the loop
   const unsigned int max_iterations;
@@ -232,7 +245,10 @@ struct PERF_TALER_MINTDB_loop_details
 };
 
 
-struct PERF_TALER_MINTDB_loop_end_details  
+/**
+ * Extra data requiered by the LOOP_END command
+ */
+struct PERF_TALER_MINTDB_CMD_loop_end_details  
 {
   /**
    * Label of the loop closed by the command
@@ -244,16 +260,18 @@ struct PERF_TALER_MINTDB_loop_end_details
 /**
  * Details about the GAUGER command
  */
-struct PERF_TALER_MINTDB_gauger_details
+struct PERF_TALER_MINTDB_CMD_gauger_details
 {
   /**
    * Label of the starting timestamp
    */
   const char *label_start;
+
   /**
    * Label of the ending timestamp
    */
   const char *label_stop;
+
   /**
    * Description of the metric, used in GAUGER
    */
@@ -262,9 +280,9 @@ struct PERF_TALER_MINTDB_gauger_details
 
 
 /**
- * Contains details about a command
+ * Contains extra data requiered by the SAVE_ARRAY command
  */
-struct PERF_TALER_MINTDB_save_array_details
+struct PERF_TALER_MINTDB_CMD_save_array_details
 {
   /**
    * Number of items to save
@@ -293,39 +311,51 @@ struct PERF_TALER_MINTDB_save_array_details
 };
 
 
-struct PERF_TALER_MINTDB_load_array_details
+/**
+ * Extra data required for the LOAD_ARRAY command
+ */
+struct PERF_TALER_MINTDB_CMD_load_array_details
 {
   /**
-   * TODO Remove references to nb and use the link to the loop to initialize
-   */
-  int nb;
-  /**
-   * The loop in which the comand is located
+   * The loop in which the command is located
    */
   const char *label_loop;
+
   /**
    * Label of the command where the items were saved
    */
   const char *label_save;
+  
   /**
    * A permutation array used to randomize the order the items are loaded in
    */
   unsigned int *permutation; // A permutation array to randomize the order the deposits are loaded in
 };
 
-struct PERF_TALER_MINTDB_get_deposit_details
+
+/**
+ * Extra data requiered for the GET_DEPOSIT command
+ */
+struct PERF_TALER_MINTDB_CMD_get_deposit_details
 {
-  const char *source;
+  /**
+   * The label of the source of the deposit to check
+   */
+  const char *label_source;
 };
 
-union PERF_TALER_MINTDB_Details
+
+/**
+ * Contains extra data required for any command
+ */
+union PERF_TALER_MINTDB_CMD_Details
 {
-  struct PERF_TALER_MINTDB_loop_details loop;
-  struct PERF_TALER_MINTDB_loop_end_details end_loop;
-  struct PERF_TALER_MINTDB_gauger_details gauger;
-  struct PERF_TALER_MINTDB_save_array_details save_array;
-  struct PERF_TALER_MINTDB_load_array_details load_array;
-  struct PERF_TALER_MINTDB_get_deposit_details get_deposit;
+  struct PERF_TALER_MINTDB_CMD_loop_details loop;
+  struct PERF_TALER_MINTDB_CMD_loop_end_details end_loop;
+  struct PERF_TALER_MINTDB_CMD_gauger_details gauger;
+  struct PERF_TALER_MINTDB_CMD_save_array_details save_array;
+  struct PERF_TALER_MINTDB_CMD_load_array_details load_array;
+  struct PERF_TALER_MINTDB_CMD_get_deposit_details get_deposit;
 };
 
 
@@ -334,6 +364,9 @@ union PERF_TALER_MINTDB_Details
  */
 struct PERF_TALER_MINTDB_Cmd
 {
+  /**
+   *  Type of the command
+   */
   enum PERF_TALER_MINTDB_CMD_Name command;
 
   /**
@@ -344,7 +377,7 @@ struct PERF_TALER_MINTDB_Cmd
   /**
    * Command specific data
    */
-  union PERF_TALER_MINTDB_Details details;
+  union PERF_TALER_MINTDB_CMD_Details details;
 
   /**
    * Type of the data exposed
@@ -362,9 +395,8 @@ struct PERF_TALER_MINTDB_Cmd
 
 int
 PERF_TALER_MINTDB_interpret(
-    struct TALER_MINTDB_Plugin *db_plugin,
-    struct TALER_MINTDB_Session *session, // add START_SESSION CMD
-    struct PERF_TALER_MINTDB_Cmd cmd[]);
+  struct TALER_MINTDB_Plugin *db_plugin,
+  struct PERF_TALER_MINTDB_Cmd cmd[]);
 
 
 #endif