taler/exchange
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Christian Grothoff 2015-06-11 16:03:11 +02:00
commit 239aaf53d4
5 changed files with 427 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/mintdb/Makefile.am
View File

@ -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

41
src/mintdb/perf_taler_mintdb.c
View File

@ -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"),
GNUNET_CONFIGURATION_load(config, "./test-mint-db-postgres.conf");
INIT_CMD_END("end")
};
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);
PERF_TALER_MINTDB_interpret(plugin, session, test);
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"),
plugin->drop_temporary(plugin->cls, session);
PERF_TALER_MINTDB_INIT_CMD_END("end")
};
PERF_TALER_MINTDB_interpret(plugin, test);
// Free the session ??
TALER_MINTDB_plugin_unload(plugin);
return GNUNET_OK;

107
src/mintdb/perf_taler_mintdb_init.c
View File

@ -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);
@ -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
{
@ -236,6 +241,7 @@ deposit_init ()
unsigned_data.purpose.size = sizeof (unsigned_data);
unsigned_data.purpose.purpose = GNUNET_SIGNATURE_PURPOSE_TEST;
unsigned_data.data = random_int;
@ -248,6 +254,7 @@ deposit_init ()
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);

314
src/mintdb/perf_taler_mintdb_interpreter.c
View File

@ -23,6 +23,51 @@
#include "../include/gauger.h"
/**
* 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
*
@ -30,7 +75,7 @@
* 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;
}
@ -127,176 +167,192 @@ 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_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_START_TRANSACTION:
db_plugin->start(db_plugin->cls, session);
state->plugin->start (state->plugin->cls, state->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;
}
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);
}
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);
// TODO check the logic here. It probably can be improved
// 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))
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);
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){
/* 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
]];
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;
}

244
src/mintdb/perf_taler_mintdb_interpreter.h
View File

@ -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