summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2016-06-15 19:24:48 +0200
committerChristian Grothoff <christian@grothoff.org>2016-06-15 22:55:05 +0200
commitc38a7c5518418caefd1c6725a29cfa577d40e7a4 (patch)
tree3ea1450f7d231fa741bdc2992a1c141caf6420e0 /src
parent754c4ef24c7758755136309661dbbb38fd75cd8d (diff)
downloadexchange-c38a7c5518418caefd1c6725a29cfa577d40e7a4.tar.gz
exchange-c38a7c5518418caefd1c6725a29cfa577d40e7a4.tar.bz2
exchange-c38a7c5518418caefd1c6725a29cfa577d40e7a4.zip
more sanity checks, better clean up
Diffstat (limited to 'src')
-rw-r--r--src/benchmark/taler-exchange-benchmark.c125
1 files changed, 85 insertions, 40 deletions
diff --git a/src/benchmark/taler-exchange-benchmark.c b/src/benchmark/taler-exchange-benchmark.c
index 9c4b8cbf..4b50033d 100644
--- a/src/benchmark/taler-exchange-benchmark.c
+++ b/src/benchmark/taler-exchange-benchmark.c
@@ -31,13 +31,24 @@
/**
* How much slack do we leave in terms of coins that are invalid (and
- * thus available for refresh)?
+ * thus available for refresh)? Should be significantly larger
+ * than #REFRESH_SLOTS_NEEDED, and must be below #pool_size.
*/
-#define INVALID_COIN_SLACK 10
+#define INVALID_COIN_SLACK 20
/**
- * The benchmark withdraws always the same denomination, since the calculation
- * for refreshing is statically done (at least in its very first version).
+ * How much slack must we have to do a refresh? Should be the
+ * maximum number of coins a refresh can generate, and thus
+ * larger than log(base 2) of #COIN_VALUE. Must also be
+ * smaller than #INVALID_COIN_SLACK and smaller than 64.
+ */
+#define REFRESH_SLOTS_NEEDED 5
+
+/**
+ * The benchmark withdraws always the same denomination, since the
+ * calculation for refreshing is statically done (at least in this
+ * first version). In the future, this will be the largest value
+ * we ever withdraw.
*/
#define COIN_VALUE 8
@@ -51,13 +62,15 @@
#define REFRESH_PROBABILITY 0.1
/**
- * Large enough value to allow having 12 coins per reserve without parsing
- * /keys in the first place
+ * What is the amount we deposit into a reserve each time.
+ * We keep it simple and always deposit the same amount for now.
*/
#define RESERVE_VALUE 1000
/**
- * How many coins (AKA withdraw operations) per reserve should be withdrawn at the same time.
+ * What should be the ratio of coins withdrawn per reserve?
+ * We roughly match #RESERVE_VALUE / #COIN_VALUE, as that
+ * matches draining the reserve.
*/
#define COINS_PER_RESERVE 12
@@ -68,17 +81,15 @@
#define WARM_THRESHOLD 1000LL
/**
- * List of coins to get in return to a melt operation. Just a
- * static list for now as every melt operation is carried out
- * on a 8 KUDOS coin whose only 1 KUDOS has been spent, thus
- * 7 KUDOS melted. This structure must be changed with one holding
- * TALER_Amount structs, as every time it's needed it requires
- * too many operations before getting the desired TALER_Amount.
+ * List of coins to get in return to a melt operation, in order
+ * of preference. The values from this structure are converted
+ * to the #refresh_pk array. Must be NULL-terminated. The
+ * currency is omitted as we get that from /keys.
*/
static const char *refresh_denoms[] = {
- "4",
- "2",
- "1",
+ "4.00",
+ "2.00",
+ "1.00",
NULL
};
@@ -578,7 +589,7 @@ reveal_cb (void *cls,
fresh_coin = invalid_coins_head;
if (NULL == fresh_coin)
{
- /* #INVALID_COIN_SLACK too low? */
+ /* #REFRESH_SLOTS_NEEDED too low? */
GNUNET_break (0);
continue;
}
@@ -594,6 +605,8 @@ reveal_cb (void *cls,
fresh_coin->coin_priv = coin_privs[i];
fresh_coin->left = coin->denoms[i];
}
+ GNUNET_free (coin->denoms);
+ coin->denoms = NULL;
continue_master_task ();
}
@@ -674,35 +687,45 @@ refresh_coin (struct Coin *coin)
{
char *blob;
size_t blob_size;
- const struct TALER_EXCHANGE_Keys *keys;
struct TALER_Amount *denoms = NULL;
struct TALER_EXCHANGE_DenomPublicKey *dpks = NULL;
const struct TALER_EXCHANGE_DenomPublicKey *curr_dpk;
struct TALER_Amount curr;
unsigned int ndenoms = 0;
unsigned int ndenoms2 = 0;
- unsigned long long acc_value;
+ unsigned int off;
TALER_amount_get_zero (currency, &curr);
- acc_value = 0;
- keys = TALER_EXCHANGE_get_keys (exchange);
- for (curr.value = COIN_VALUE >> 1; curr.value > 0; curr.value = curr.value >> 1)
+ off = 0;
+ while (0 != TALER_amount_cmp (&curr,
+ &coin->left))
{
- while (acc_value + curr.value <= coin->left.value)
+ if (off >= refresh_pk_len)
+ {
+ /* refresh currency choices do not add up! */
+ GNUNET_break (0);
+ break;
+ }
+ curr_dpk = &refresh_pk[off];
+ while (-1 != TALER_amount_cmp (&coin->left,
+ &curr_dpk->value))
{
GNUNET_array_append (denoms,
ndenoms,
- curr);
- GNUNET_assert (NULL != (curr_dpk = find_pk (keys, &curr)));
+ curr_dpk->value);
GNUNET_array_append (dpks,
ndenoms2,
*curr_dpk);
- acc_value += curr.value;
+ TALER_amount_subtract (&coin->left,
+ &coin->left,
+ &curr_dpk->value);
}
+ off++;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"# of coins to get in melt: %d\n",
ndenoms2);
+ GNUNET_break (ndenoms2 <= REFRESH_SLOTS_NEEDED);
blob = TALER_EXCHANGE_refresh_prepare (&coin->coin_priv,
&coin->left,
&coin->sig,
@@ -712,9 +735,6 @@ refresh_coin (struct Coin *coin)
dpks,
&blob_size);
invalidate_coin (coin);
- GNUNET_array_grow (denoms,
- ndenoms,
- 0);
GNUNET_array_grow (dpks,
ndenoms2,
0);
@@ -1136,6 +1156,8 @@ benchmark_run (void *cls)
refresh = GNUNET_NO; /* cannot refresh, coin is already at unit */
else
refresh = eval_probability (REFRESH_PROBABILITY);
+ if (num_invalid_coins < REFRESH_SLOTS_NEEDED)
+ refresh = GNUNET_NO;
spend_coin (coin,
refresh);
return;
@@ -1149,12 +1171,11 @@ benchmark_run (void *cls)
* be withdrawn in a refresh operation. It sums up 4 #currency units,
* since that is the only amount refreshed so far by the benchmark
*
- * @param NULL-terminated array of value.fraction pairs
* @return #GNUNET_OK if the array is correctly built, #GNUNET_SYSERR
* otherwise
*/
static unsigned int
-build_refresh (const char *const*list)
+build_refresh ()
{
char *amount_str;
struct TALER_Amount amount;
@@ -1162,13 +1183,16 @@ build_refresh (const char *const*list)
const struct TALER_EXCHANGE_DenomPublicKey *picked_denom;
const struct TALER_EXCHANGE_Keys *keys;
+ GNUNET_array_grow (refresh_pk,
+ refresh_pk_len,
+ 0);
keys = TALER_EXCHANGE_get_keys (exchange);
- for (i=0; NULL != list[i]; i++)
+ for (i=0; NULL != refresh_denoms[i]; i++)
{
GNUNET_asprintf (&amount_str,
"%s:%s",
currency,
- list[i]);
+ refresh_denoms[i]);
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount (amount_str,
&amount));
@@ -1219,17 +1243,26 @@ cert_cb (void *cls,
_keys->num_sign_keys,
_keys->num_denom_keys);
if (NULL != currency)
- return; /* we've been here before... */
+ {
+ /* we've been here before, still need to update refresh_denoms */
+ if (GNUNET_SYSERR ==
+ build_refresh ())
+ {
+ fail ("Initializing denominations failed");
+ return;
+ }
+ return;
+ }
currency = GNUNET_strdup (_keys->denom_keys[0].value.currency);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Using currency: %s\n",
- currency);
if (GNUNET_SYSERR ==
- build_refresh (refresh_denoms))
+ build_refresh ())
{
fail ("Initializing denominations failed");
return;
}
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Using currency: %s\n",
+ currency);
continue_master_task ();
}
@@ -1312,6 +1345,11 @@ do_shutdown (void *cls)
GNUNET_CRYPTO_rsa_signature_free (coin->sig.rsa_signature);
coin->sig.rsa_signature = NULL;
}
+ if (NULL != coin->denoms)
+ {
+ GNUNET_free (coin->denoms);
+ coin->denoms = NULL;
+ }
}
if (NULL != bank_details)
{
@@ -1387,8 +1425,6 @@ run (void *cls)
unsigned int i;
unsigned int j;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "running run()\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"gotten pool_size of %d\n",
pool_size);
@@ -1407,6 +1443,11 @@ run (void *cls)
fail ("Failed to parse configuration file");
return;
}
+ if (pool_size < INVALID_COIN_SLACK)
+ {
+ fail ("Pool size given too small.");
+ return;
+ }
if (GNUNET_SYSERR ==
GNUNET_CONFIGURATION_get_value_filename (cfg,
"benchmark",
@@ -1460,6 +1501,8 @@ run (void *cls)
sizeof (blinding_key));
nreserves = pool_size / COINS_PER_RESERVE;
+ if (COINS_PER_RESERVE * nreserves < pool_size)
+ nreserves++;
reserves = GNUNET_new_array (nreserves,
struct Reserve);
ncoins = COINS_PER_RESERVE * nreserves;
@@ -1535,6 +1578,8 @@ main (int argc,
GNUNET_log_setup ("taler-exchange-benchmark",
"WARNING",
NULL);
+ GNUNET_assert (INVALID_COIN_SLACK >= REFRESH_SLOTS_NEEDED);
+ GNUNET_assert (COIN_VALUE <= (1LL << REFRESH_SLOTS_NEEDED));
ret = GNUNET_GETOPT_run ("taler-exchange-benchmark",
options, argc, argv);
GNUNET_assert (GNUNET_SYSERR != ret);