diff options
| -rw-r--r-- | src/mintdb/perf/perf_taler_mintdb.c | 42 | ||||
| -rw-r--r-- | src/mintdb/perf/perf_taler_mintdb_init.c | 258 | ||||
| -rw-r--r-- | src/mintdb/perf/perf_taler_mintdb_init.h | 38 | ||||
| -rw-r--r-- | src/mintdb/perf/perf_taler_mintdb_interpreter.c | 317 | ||||
| -rw-r--r-- | src/mintdb/perf/perf_taler_mintdb_interpreter.h | 147 | ||||
| -rw-r--r-- | src/mintdb/perf/perf_taler_mintdb_values.h | 17 |
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 |