aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/mintdb/perf/perf_taler_mintdb.c42
-rw-r--r--src/mintdb/perf/perf_taler_mintdb_init.c258
-rw-r--r--src/mintdb/perf/perf_taler_mintdb_init.h38
-rw-r--r--src/mintdb/perf/perf_taler_mintdb_interpreter.c317
-rw-r--r--src/mintdb/perf/perf_taler_mintdb_interpreter.h147
-rw-r--r--src/mintdb/perf/perf_taler_mintdb_values.h17
6 files changed, 819 insertions, 0 deletions
diff --git a/src/mintdb/perf/perf_taler_mintdb.c b/src/mintdb/perf/perf_taler_mintdb.c
new file mode 100644
index 000000000..3d8f1a77e
--- /dev/null
+++ b/src/mintdb/perf/perf_taler_mintdb.c
@@ -0,0 +1,42 @@
+#include "perf_taler_mintdb_interpreter.h"
+
+
+
+
+
+int
+main(int argc, char ** argv)
+{
+
+ 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")
+ };
+
+ struct GNUNET_CONFIGURATION_Handle *config = GNUNET_CONFIGURATION_create();
+
+ // FIXME Add data to the config handler to be able to connect to the database
+
+ struct TALER_MINTDB_Plugin *plugin = TALER_MINTDB_plugin_load(config);
+ struct TALER_MINTDB_Session *session = plugin->get_session(plugin->cls, GNUNET_YES);
+
+ plugin->create_tables(plugin->cls, GNUNET_YES);
+
+
+ PERF_TALER_MINTDB_interprete(plugin, session, test);
+
+
+ plugin->drop_temporary(plugin->cls, session);
+
+ // Free the session ??
+
+ TALER_MINTDB_plugin_unload(plugin);
+ return GNUNET_OK;
+}
diff --git a/src/mintdb/perf/perf_taler_mintdb_init.c b/src/mintdb/perf/perf_taler_mintdb_init.c
new file mode 100644
index 000000000..31be2b1bd
--- /dev/null
+++ b/src/mintdb/perf/perf_taler_mintdb_init.c
@@ -0,0 +1,258 @@
+#include <gnunet/platform.h>
+#include <gnunet/gnunet_crypto_lib.h>
+#include <gnunet/gnunet_signatures.h>
+
+#include <taler/taler_mintdb_plugin.h>
+#include <taler/taler_signatures.h>
+#include <taler/taler_amount_lib.h>
+
+
+#define CURRENCY "EUR\0\0\0\0\0\0\0\0"
+
+struct TALER_MINTDB_CollectableBlindcoin *
+init_CollectableBlindcoin(){
+ struct TALER_MINTDB_CollectableBlindcoin *coin = GNUNET_malloc(sizeof(*coin));
+
+ struct GNUNET_CRYPTO_EddsaPrivateKey *reserve_sig_key = GNUNET_CRYPTO_eddsa_key_create();
+ struct GNUNET_CRYPTO_rsa_PrivateKey *denomination_key = GNUNET_CRYPTO_rsa_private_key_create(512);
+
+
+ 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));
+
+
+ //TODO Randomise the amount that is deposited and apply a fee subsequently
+
+ coin->amount_with_fee = (struct TALER_Amount) {1, 1, CURRENCY};
+ coin->withdraw_fee = (struct TALER_Amount) {0, 1, CURRENCY};
+
+
+ int random_int = rand();
+ coin->sig.rsa_signature = GNUNET_CRYPTO_rsa_sign(denomination_key, &random_int, sizeof(random_int));
+ GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK , &(coin->h_coin_envelope));
+
+ void *purpose = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) + sizeof(int));
+ ((struct GNUNET_CRYPTO_EccSignaturePurpose *)purpose)->size = sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) + sizeof(int);
+ ((struct GNUNET_CRYPTO_EccSignaturePurpose *)purpose)->purpose = GNUNET_SIGNATURE_PURPOSE_TEST;
+ *((int *)(purpose + sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose))) = random_int;
+
+ GNUNET_CRYPTO_eddsa_sign(reserve_sig_key, purpose, &coin->reserve_sig.eddsa_signature);
+
+
+
+ GNUNET_free(reserve_sig_key);
+ GNUNET_CRYPTO_rsa_private_key_free(denomination_key);
+ return coin;
+}
+
+
+struct TALER_MINTDB_Reserve *
+init_Reserve(){
+ struct TALER_MINTDB_Reserve *reserve = GNUNET_malloc(sizeof(*reserve));
+ struct GNUNET_CRYPTO_EddsaPrivateKey *reserve_priv = GNUNET_CRYPTO_eddsa_key_create();
+
+ GNUNET_CRYPTO_eddsa_key_get_public(reserve_priv , &(reserve->pub.eddsa_pub));
+
+
+ reserve->balance = (struct TALER_Amount){1, 1, CURRENCY};
+ reserve->expiry = GNUNET_TIME_absolute_get_forever_();
+
+ GNUNET_free(reserve_priv);
+ return reserve;
+}
+
+
+struct TALER_MINTDB_RefreshSession *
+init_Refresh_session(){
+ struct TALER_MINTDB_RefreshSession *refresh_session = GNUNET_malloc(sizeof(*refresh_session));
+
+ refresh_session->noreveal_index = 1;
+ refresh_session->num_oldcoins = 1;
+ refresh_session->num_newcoins = 1;
+
+ return refresh_session;
+}
+
+
+struct TALER_MINTDB_Deposit *
+init_Deposit(){
+ static int transaction_id = 0;
+
+ struct TALER_MINTDB_Deposit *deposit = GNUNET_malloc(sizeof(*deposit));
+
+ deposit-> transaction_id = transaction_id;
+ transaction_id++;
+
+
+ //TODO Randomize the amount that is deposited
+
+ deposit->amount_with_fee = (struct TALER_Amount) {1, 1, CURRENCY};
+ deposit->deposit_fee = (struct TALER_Amount) {0, 1, CURRENCY};
+
+ deposit->timestamp = GNUNET_TIME_absolute_get();
+ deposit->refund_deadline = GNUNET_TIME_absolute_get();
+
+ GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &deposit->h_contract);
+ GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &deposit->h_wire);
+
+ // Coin Spend Signature
+ {
+ struct GNUNET_CRYPTO_EddsaSignature sig;
+
+ struct GNUNET_CRYPTO_EddsaPrivateKey *p_eddsa_prvt = GNUNET_CRYPTO_eddsa_key_create();
+ void *prp = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)+sizeof(int));
+ *((struct GNUNET_CRYPTO_EccSignaturePurpose *)prp) =(struct GNUNET_CRYPTO_EccSignaturePurpose) {sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)+sizeof(int), GNUNET_SIGNATURE_PURPOSE_TEST};
+
+
+ GNUNET_CRYPTO_eddsa_sign(p_eddsa_prvt, (struct GNUNET_CRYPTO_EccSignaturePurpose *) prp, &sig);
+
+ deposit->csig.eddsa_signature = sig;
+
+ GNUNET_free(p_eddsa_prvt);
+ }
+
+ // Merchant Key
+ {
+ struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
+ struct GNUNET_CRYPTO_EddsaPrivateKey *p_eddsa_prv = GNUNET_CRYPTO_eddsa_key_create();
+
+ GNUNET_CRYPTO_eddsa_key_get_public(p_eddsa_prv, &eddsa_pub);
+
+ deposit->merchant_pub.eddsa_pub = eddsa_pub;
+
+ GNUNET_free(p_eddsa_prv);
+ }
+
+ // Coin
+ {
+
+
+ {
+ struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
+ struct GNUNET_CRYPTO_EddsaPrivateKey *p_eddsa_prvt = GNUNET_CRYPTO_eddsa_key_create();
+
+ GNUNET_CRYPTO_eddsa_key_get_public(p_eddsa_prvt, &eddsa_pub);
+
+ deposit->coin.coin_pub.eddsa_pub = eddsa_pub;
+
+ GNUNET_free(p_eddsa_prvt);
+ }
+
+ {
+ struct GNUNET_CRYPTO_rsa_PrivateKey *p_rsa_prv = GNUNET_CRYPTO_rsa_private_key_create(128);
+ struct GNUNET_CRYPTO_rsa_PublicKey *p_rsa_pub = GNUNET_CRYPTO_rsa_private_key_get_public(p_rsa_prv);
+
+ deposit->coin.denom_pub.rsa_public_key = p_rsa_pub;
+
+
+
+ deposit->coin.denom_sig.rsa_signature = GNUNET_CRYPTO_rsa_sign(p_rsa_prv,
+ (void *) &(deposit->coin.coin_pub.eddsa_pub),
+ sizeof(&(deposit->coin.coin_pub.eddsa_pub)));
+
+ GNUNET_CRYPTO_rsa_private_key_free(p_rsa_prv);
+ }
+
+ }
+
+
+ return deposit;
+}
+
+
+struct TALER_MINTDB_DenominationKeyIssueInformation *
+init_denomination(){
+ struct TALER_MINTDB_DenominationKeyIssueInformation *dki = GNUNET_malloc(sizeof(&dki));
+
+
+ dki->denom_priv.rsa_private_key
+ = GNUNET_CRYPTO_rsa_private_key_create (128);
+ GNUNET_assert (NULL != dki->denom_priv.rsa_private_key);
+ dki->denom_pub.rsa_public_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,
+ &dki->issue.denom_hash);
+
+ struct GNUNET_CRYPTO_EddsaPrivateKey *master_prvt =
+ GNUNET_CRYPTO_eddsa_key_create();
+
+ struct GNUNET_CRYPTO_EddsaPublicKey master_pub;
+
+ GNUNET_CRYPTO_eddsa_key_get_public(master_prvt, &master_pub);
+ dki->issue.master.eddsa_pub = master_pub;
+
+ struct GNUNET_TIME_Absolute 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_()));
+ dki->issue.expire_spend =
+ GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
+ GNUNET_TIME_relative_get_hour_()));
+ dki->issue.expire_legal =
+ GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
+ GNUNET_TIME_relative_get_hour_()));
+
+ struct TALER_Amount amount = {.value = 1, .fraction = 1, .currency = CURRENCY};
+
+ TALER_amount_hton (&dki->issue.value, &amount);
+ TALER_amount_hton (&dki->issue.fee_withdraw, &amount);
+ TALER_amount_hton (&dki->issue.fee_deposit, &amount);
+ TALER_amount_hton (&dki->issue.fee_refresh, &amount);
+ 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));
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CRYPTO_eddsa_sign (master_prvt,
+ &dki->issue.purpose,
+ &dki->issue.signature.eddsa_signature));
+
+ return dki;
+}
+
+
+
+
+
+
+
+// Destructors
+
+
+int
+free_deposit(struct TALER_MINTDB_Deposit *deposit){
+ GNUNET_free(deposit->coin.denom_pub.rsa_public_key);
+ GNUNET_free(deposit->coin.denom_sig.rsa_signature);
+
+ GNUNET_free(deposit);
+
+ return GNUNET_OK;
+}
+
+
+int
+free_coin(struct TALER_MINTDB_CollectableBlindcoin *coin){
+ GNUNET_free(coin->sig.rsa_signature);
+ GNUNET_free(coin->denom_pub.rsa_public_key);
+
+ GNUNET_free(coin);
+
+ return GNUNET_OK;
+}
+
+
+int
+free_denomination(struct TALER_MINTDB_DenominationKeyIssueInformation *dki){
+ GNUNET_free(dki->denom_priv.rsa_private_key);
+ GNUNET_free(dki->denom_pub.rsa_public_key);
+
+ GNUNET_free(dki);
+
+ return GNUNET_OK;
+}
+
+
+
+
diff --git a/src/mintdb/perf/perf_taler_mintdb_init.h b/src/mintdb/perf/perf_taler_mintdb_init.h
new file mode 100644
index 000000000..37a9ccbb8
--- /dev/null
+++ b/src/mintdb/perf/perf_taler_mintdb_init.h
@@ -0,0 +1,38 @@
+#ifndef __PERF_TALER_MINTDB_INIT_H___
+#define __PERF_TALER_MINTDB_INIT_H___
+
+
+#include <gnunet/platform.h>
+
+#include <taler/taler_mintdb_lib.h>
+#include <taler/taler_mintdb_plugin.h>
+
+
+#define CURRENCY "EUR\0\0\0\0\0\0\0\0"
+
+
+struct TALER_MINTDB_CollectableBlindcoin *
+init_collectableBlindcoin();
+
+struct TALER_MINTDB_RefreshSession *
+init_refresh_session();
+
+struct TALER_MINTDB_Deposit *
+init_deposit(int transaction_id);
+
+struct TALER_MINTDB_DenominationKeyIssueInformation *
+init_denomination();
+
+
+
+int
+free_deposit(struct TALER_MINTDB_Deposit *deposit);
+
+int
+free_collectableBlindcoin(struct TALER_MINTDB_CollectableBlindcoin);
+
+int
+free_denomination(struct TALER_MINTDB_DenominationKeyIssueInformation *dki);
+
+
+#endif
diff --git a/src/mintdb/perf/perf_taler_mintdb_interpreter.c b/src/mintdb/perf/perf_taler_mintdb_interpreter.c
new file mode 100644
index 000000000..9c26c70f4
--- /dev/null
+++ b/src/mintdb/perf/perf_taler_mintdb_interpreter.c
@@ -0,0 +1,317 @@
+#include "perf_taler_mintdb_interpreter.h"
+
+#include "perf_taler_mintdb_init.h"
+
+#include <gauger.h>
+
+
+/**
+ * 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)
+{
+ int i = 0;
+ while (0)
+ {
+ if (cmd[i].command == CMD_END)
+ {
+ return GNUNET_SYSERR;
+ }
+
+ if (0 != strcmp(cmd[i].name, search))
+ {
+ return i;
+ }
+ i++;
+ }
+}
+
+
+// Initialization of a command array
+ static int
+cmd_init(struct PERF_TALER_MINTDB_CMD cmd[])
+{
+ int i = 0;
+ while (cmd[i].command != CMD_END)
+ {
+ switch (cmd[i].command)
+ {
+ case CMD_SAVE_ARRAY:
+
+ // Initialization is done differently depending of the type saved
+ switch (cmd[i].details.save_array.saved_type)
+ {
+ case DEPOSIT:
+ cmd[i].details.save_array.saved_data.deposit =
+ GNUNET_malloc(cmd[i].details.save_array.nb*
+ sizeof(*cmd[i].details.save_array.saved_data.deposit));
+ break;
+ case TIME:
+ cmd[i].details.save_array.saved_data.time =
+ GNUNET_malloc(cmd[i].details.save_array.nb*
+ sizeof(*cmd[i].details.save_array.saved_data.time));
+
+ default:
+ break;
+ }
+ break;
+
+ case CMD_LOAD_ARRAY:
+ cmd[i].details.load_array.permutation =
+ GNUNET_CRYPTO_random_permute(
+ GNUNET_CRYPTO_QUALITY_WEAK,
+ cmd[i].details.load_array.nb);
+ break;
+ default:
+ break;
+ }
+
+ i++;
+ }
+
+ return GNUNET_OK;
+}
+
+
+/**
+ * Free the memory of the command chain
+ */
+ static int
+cmd_clean(struct PERF_TALER_MINTDB_CMD cmd[])
+{
+ int i = 0;
+ while (cmd[i].command != CMD_END)
+ {
+ switch (cmd[i].command)
+ {
+ case CMD_SAVE_ARRAY:
+ {
+ int j;
+ switch (cmd[i].details.save_array.saved_type)
+ {
+ case DEPOSIT:
+ for (j = 0; j < cmd[i].details.save_array.nb; j++)
+ {
+ free_deposit(cmd[i].details.save_array.saved_data.deposit[j]);
+ cmd[i].details.save_array.saved_data.deposit[j] = NULL;
+ }
+ GNUNET_free(cmd[i].details.save_array.saved_data.deposit);
+ cmd[i].details.save_array.saved_data.deposit = NULL;
+ break;
+ case TIME:
+ GNUNET_free(cmd[i].details.save_array.saved_data.time);
+ break;
+ default:
+ break;
+ }
+ }
+
+ case CMD_INSERT_DEPOSIT:
+ free_deposit(cmd[i].exposed.deposit);
+ break;
+
+ case CMD_LOAD_ARRAY:
+ GNUNET_free(cmd[i].details.load_array.permutation);
+ break;
+
+ default:
+ break;
+
+ }
+ i++;
+ }
+ return GNUNET_OK;
+}
+
+
+/**
+ *
+ */
+ static int
+interprete(struct TALER_MINTDB_Plugin *db_plugin,
+ struct TALER_MINTDB_Session*session,
+ struct PERF_TALER_MINTDB_CMD cmd[])
+{
+ int i=0;
+ while (0){
+ switch (cmd[i].command)
+ {
+ case CMD_END:
+ return GNUNET_YES;
+ break;
+
+ case CMD_LOOP:
+ cmd[i].details.loop.curr_iteration++;
+ break;
+
+ case CMD_END_LOOP:
+ {
+ int jump = cmd_find(cmd, cmd[i].details.end_loop.loop_start);
+ zf (cmd[jump].details.loop.max_iterations > cmd[jump].details.loop.curr_iteration)
+ {
+ i = jump -1;
+ }else{
+ int j;
+ // For each command in the loop
+ for (j = 0; j <i; j++){
+ // If the exposed variable has not been copied
+ if (!cmd[j].exposed_used)
+ {
+ cmd[j].exposed_used = 0;
+ // It is freed
+ switch (cmd[j].command){
+ case CMD_INSERT_DEPOSIT:
+ free_deposit(cmd[j].exposed.deposit);
+ cmd[j].exposed.deposit = NULL;
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+
+
+ case CMD_GET_TIME:
+ clock_gettime(CLOCK_MONOTONIC, &cmd[i].exposed.time);
+ break;
+
+
+ case CMD_GAUGER:
+ {
+ int start_index = cmd_find(cmd, cmd[i].details.gauger.start_time);
+ int stop_index = cmd_find(cmd, cmd[i].details.gauger.stop_time );
+ struct timespec start= cmd[start_index].exposed.time;
+ struct timespec stop = 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");
+ }
+ break;
+
+ case CMD_START_TRANSACTION:
+ db_plugin->start(db_plugin->cls, session);
+ break;
+
+
+ case CMD_COMMIT_TRANSACTION:
+ db_plugin->commit(db_plugin->cls, session);
+ break;
+
+
+ case CMD_INSERT_DEPOSIT:
+ {
+ struct TALER_MINTDB_Deposit *deposit = init_deposit(0);
+ db_plugin->insert_deposit(db_plugin->cls, session, deposit);
+
+ cmd[i].exposed.deposit = deposit;
+ }
+ break;
+
+
+ case 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);
+ }
+ break;
+
+
+ case CMD_SAVE_ARRAY:
+ {
+ // Array initialization on first loop iteration
+ if (cmd[cmd_find(cmd, cmd[i].details.save_array.loop)].details.loop.curr_iteration == 0)
+ {
+ cmd[i].details.save_array.index = 0;
+ }
+
+ int loop_index = cmd_find(cmd, cmd[i].details.save_array.loop);
+ int proba = cmd[loop_index].details.loop.max_iterations / cmd[i].details.save_array.nb;
+ 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 - cmd[i].details.save_array.index) ||
+ (rnd == 0 && cmd[i].details.save_array.index < cmd[i].details.save_array.nb))
+ {
+
+ // We automaticly save the whatever we need to
+ switch (cmd[i].details.save_array.saved_type){
+ case DEPOSIT:
+ cmd[i].details.save_array.saved_data.deposit[cmd[i].details.save_array.index] =
+ cmd[cmd_find(cmd, cmd[i].details.save_array.saved)].exposed.deposit;
+ break;
+ case TIME:
+ cmd[i].details.save_array.saved_data.deposit[cmd[i].details.save_array.index] =
+ cmd[cmd_find(cmd, cmd[i].details.save_array.saved)].exposed.deposit;
+ break;
+ }
+ cmd[i].details.save_array.index++;
+ }
+ }
+ break;
+
+
+ case CMD_LOAD_ARRAY:
+ {
+
+ int loop_index = cmd_find(cmd, cmd[i].details.load_array.loop);
+ int save_index = cmd_find(cmd, cmd[i].details.load_array.saved);
+ switch (cmd[i].details.load_array.loaded_type){
+ case DEPOSIT:
+ cmd[i].exposed.deposit = cmd[save_index].details.save_array.saved_data.deposit[
+ cmd[i].details.load_array.permutation[
+ cmd[loop_index].details.loop.curr_iteration
+ ]
+ ];
+ break;
+
+ case TIME:
+ cmd[i].exposed.time = cmd[save_index].details.save_array.saved_data.time[
+ cmd[i].details.load_array.permutation[
+ cmd[loop_index].details.loop.curr_iteration
+ ]
+ ];
+ break;
+ default:
+ break;
+
+ }
+ }
+ }
+ i++;
+ }
+ return GNUNET_OK;
+}
+
+/**
+ * Runs the commands given in cmd, working with
+ * the database referenced by db_plugin
+ */
+ int
+PERF_TALER_MINTDB_interprete(struct TALER_MINTDB_Plugin *db_plugin,
+ struct TALER_MINTDB_Session *session,
+ struct PERF_TALER_MINTDB_CMD cmd[])
+{
+
+ // Initializing commands
+ cmd_init(cmd);
+
+ // Running the interpreter
+ interprete(db_plugin, session, cmd);
+
+ // Cleaning the memory
+ cmd_clean(cmd);
+
+ return GNUNET_YES;
+
+}
diff --git a/src/mintdb/perf/perf_taler_mintdb_interpreter.h b/src/mintdb/perf/perf_taler_mintdb_interpreter.h
new file mode 100644
index 000000000..c39cfd584
--- /dev/null
+++ b/src/mintdb/perf/perf_taler_mintdb_interpreter.h
@@ -0,0 +1,147 @@
+#ifndef __PERF_TALER_MINTDB_INTERPRETER_H__
+#define __PERF_TALER_MINTDB_INTERPRETER_H__
+
+#include <sys/time.h>
+
+#include <gnunet/platform.h>
+#include <taler/taler_mintdb_lib.h>
+#include <taler/taler_mintdb_plugin.h>
+
+
+
+#define INIT_CMD_LOOP(label, _iter) {.command = CMD_LOOP, .name = label, .details.loop = {.max_iterations = _iter, .curr_iteration = -1} }
+
+#define INIT_CMD_END_LOOP(label, _loopname) {.command = CMD_END_LOOP, .name = label, .details.end_loop.loop_start = _loopname}
+
+#define INIT_CMD_END(label) {.command = CMD_END, .name = label}
+
+#define INIT_CMD_GET_TIME(label) {.command = CMD_GET_TIME, .name = label}
+
+#define INIT_CMD_GAUGER(label, _start_time, _stop_time, _description) {.command = CMD_GAUGER, .name = label, .details.gauger = {.start_time = _start_time, .end_time = _endtime, .description = _description} }
+
+#define INIT_CMD_START_TRANSACTION(label) {.command = CMD_START_TRANSACTION, .name = label}
+
+#define INIT_CMD_COMMIT_TRANSACTION(label) {.command = CMD_COMMIT_TRANSACTION, .name = label}
+
+
+
+#define INIT_CMD_INSERT_DEPOSIT(label) {.command = CMD_INSERT_DEPOSIT, .name = label}
+
+#define INIT_CMD_GET_DEPOSIT(label, _saved) {.command = CMD_GET_DEPOSIT, .name = label, .details.get_deposit.saved = _source }
+
+#define INIT_CMD_SAVE_DEPOSIT(label, _loop, _save, _nb) {.command = CMD_SAVE_ARRAY, .name = label, .details.save_array = {.loop = _loop, .nb = _nb, .saved = _save, saved_type = DEPOSIT} }
+
+#define INIT_CMD_LOAD_DEPOSIT(label, _loop, _save, _nb) {.command = CMD_LOAD_ARRAY, .name = label, .details.load_array = {.loop = _loop, .nb = _nb, .saved = _save} }
+
+
+
+enum PERF_TALER_MINTDB_TYPE {
+ DEPOSIT,
+ TIME,
+};
+
+/**
+ * Command to be interpreted.
+ *
+ */
+struct PERF_TALER_MINTDB_CMD{
+
+ enum {
+
+ // Define the start of al command chain loop
+ CMD_LOOP,
+ // Define the end of a command chain loop
+ CMD_END_LOOP,
+
+ // All comand chain must hace this as their last command
+ CMD_END,
+
+ // Save the time at which the command was executed
+ CMD_GET_TIME,
+
+ // Upload performance to Gauger
+ CMD_GAUGER,
+
+ // Start a database transaction
+ CMD_START_TRANSACTION,
+
+ // End a database transaction
+ CMD_COMMIT_TRANSACTION,
+
+ // Insert a deposit into the database
+ CMD_INSERT_DEPOSIT,
+
+ // Check if a deposit is in the database
+ CMD_GET_DEPOSIT,
+
+ // Saves random deposits from a loop
+ CMD_SAVE_ARRAY,
+
+ // Load deposits saved earlyer
+ CMD_LOAD_ARRAY,
+
+ } command;
+
+ char name[40];
+
+ // Contains command specific data.
+ union {
+ struct {
+ const int max_iterations;
+ int curr_iteration;
+ } loop;
+
+ struct {
+ char loop_start[40];
+ } end_loop;
+
+ struct {
+ char start_time[40];
+ char stop_time[40];
+
+ char description[40];
+ } gauger;
+
+ struct {
+ int nb; // Number of deposits to save
+ int index; // The number of deposits already saved
+ char loop[40]; // The loop from which the data will be extracted
+ char saved[40]; // The deposit saved
+ enum PERF_TALER_MINTDB_TYPE saved_type;
+ union {
+ struct TALER_MINTDB_Deposit **deposit;
+ struct timespec *time;
+ } saved_data;
+ } save_array;
+
+ struct {
+ int nb; //the number of deposits to save
+ char loop[40];
+ char saved[40]; // The command where the deposit were saved
+ enum PERF_TALER_MINTDB_TYPE loaded_type;
+ unsigned int *permutation; // A permutation array to randomize the order the deposits are loaded in
+ } load_array;
+
+ struct {
+ char source[40];
+ } get_deposit;
+
+
+ } details;
+ union {
+ struct TALER_MINTDB_Deposit *deposit;
+ struct timespec time;
+ } exposed;
+
+ int exposed_used;
+};
+
+
+int
+PERF_TALER_MINTDB_interprete(
+ struct TALER_MINTDB_Plugin *db_plugin,
+ struct TALER_MINTDB_Session *session,
+ struct PERF_TALER_MINTDB_CMD cmd[]);
+
+
+#endif
diff --git a/src/mintdb/perf/perf_taler_mintdb_values.h b/src/mintdb/perf/perf_taler_mintdb_values.h
new file mode 100644
index 000000000..09343d869
--- /dev/null
+++ b/src/mintdb/perf/perf_taler_mintdb_values.h
@@ -0,0 +1,17 @@
+#ifndef __PERF_TALER_MINTDB__VALUES_H__
+#define __PERF_TALER_MINTDB__VALUES_H__
+
+
+
+#define NB_DEPOSIT_INIT 100000
+#define NB_DEPOSIT_GET 1000
+#define NB_DEPOSIT_MARGIN 10000
+
+#define NB_BLINDCOIN_INIT 100000
+
+
+// Temporary macro to compile
+#define GAUGER(a,b,c,d)
+
+
+#endif