void ssh_busy_wait_usec(const SshUInt64 time_us)
{
SshTimeMeasure timer;
timer = ssh_time_measure_allocate();
ssh_time_measure_start(timer);
while (ssh_time_measure_stamp(timer,
SSH_TIME_GRANULARITY_MICROSECOND) <
time_us)
/*NOTHING*/;
ssh_time_measure_stop(timer);
ssh_time_measure_free(timer);
}
void acc_encrypt_done(SshCryptoStatus status,
const unsigned char *data,
size_t length,
void *context)
{
SshEKTestOp tc = context, ntc;
SshExternalKeyTestCtx ctx = tc->test_ctx;
SshPrivateKey key;
SshUInt32 nanos;
SshUInt64 secs;
SshUInt32 s;
ctx->operations_done++;
ssh_time_measure_get_value(tc->timer,
&secs, &nanos);
s = (SshUInt32)secs;
key = accelerator_test ? ctx->acc_prv_key : ctx->prv_key;
ctx->accelerated_encrypts_pending--;
SSH_DEBUG(2, ("Completed encrypt %d", tc->op_id));
SSH_DEBUG(3, ("Time %ds %dns", s, nanos));
ssh_time_measure_free(tc->timer);
ssh_xfree(tc);
SSH_DEBUG_HEXDUMP(7, ("Encrypted data of len %d:", length), data, length);
if (status == SSH_CRYPTO_OK)
{
SSH_DEBUG(10, ("Got the data of len %d", length));
SSH_DEBUG(10, ("Accelerated encrypt succesfull"));
ctx->accelerated_decrypts_pending++;
ntc = ssh_xcalloc(1, sizeof(*ntc));
ntc->op_id = next_op_id++;
ntc->test_ctx = ctx;
ssh_private_key_decrypt_async(key,
data, length,
acc_decrypt_done, ntc);
}
else
{
SSH_DEBUG(1, ("Accelerated encrypt unsuccesfull"));
ctx->operations_failed++;
}
}
void cipher_speed_test(char *cipher_name,
char *passphrase,
unsigned char *key, size_t key_len,
unsigned char *iv, size_t iv_len,
Boolean encrypt_mode)
{
SshCryptoStatus cs;
SshCipher cipher;
SshTimeMeasure timer;
unsigned char *data;
unsigned char *data_dest;
size_t block_len, data_len, tot, n;
int i, len_mul;
double sec;
if (!passphrase && !key)
{
passphrase = "This is a test key!";
}
if (passphrase)
{
SSH_DEBUG(5, ("Allocating %s context with passphrase.", cipher_name));
cs = ssh_cipher_allocate_with_passphrase(cipher_name,
passphrase,
encrypt_mode,
&cipher);
}
else
{
SSH_DEBUG(5, ("Allocating %s context with key vector.", cipher_name));
cs = ssh_cipher_allocate(cipher_name,
key,
key_len,
encrypt_mode,
&cipher);
}
if (cs != SSH_CRYPTO_OK)
{
switch (cs)
{
case SSH_CRYPTO_UNSUPPORTED:
fprintf(stderr, "%s: Unsupported cipher \"%s\".\n",
av0, cipher_name);
exit(-1);
case SSH_CRYPTO_KEY_TOO_SHORT:
fprintf(stderr, "%s: Key too short for \"%s\".\n", av0, cipher_name);
exit(-1);
default:
fprintf(stderr, "%s: Cipher allocate failed.\n", av0);
exit(-1);
}
/*NOTREACHED*/
}
if (iv != NULL)
{
if (ssh_cipher_get_iv_length(ssh_cipher_name(cipher)) == iv_len)
ssh_cipher_set_iv(cipher, iv);
else
{
fprintf(stderr, "%s: Weird IV length.\n", av0);
exit(1);
}
}
block_len = ssh_cipher_get_block_length(ssh_cipher_name(cipher));
data_len = CIPHER_TEST_DATA_LEN;
while (data_len % block_len != 0)
{
SSH_DEBUG(5, ("Growing test data len to match with cipher block size."));
data_len++;
}
data = ssh_xmalloc(data_len);
data_dest = ssh_xmalloc(data_len);
for (i = 0; i < data_len; i++)
data[i] = (unsigned char)(i % 0x100);
tot = data_len * 2;
timer = ssh_time_measure_allocate();
timer_retry:
n = tot;
ssh_time_measure_reset(timer);
ssh_time_measure_start(timer);
while (n > 0)
{
if (n > CIPHER_TEST_DATA_LEN)
{
cs = ssh_cipher_transform(cipher,
data_dest,
data,
CIPHER_TEST_DATA_LEN);
n -= CIPHER_TEST_DATA_LEN;
}
else
{
cs = ssh_cipher_transform(cipher,
data_dest,
data,
n);
n = 0;
}
if (cs != SSH_CRYPTO_OK)
ssh_fatal("%s: ssh_cipher_transform failed (%d).", av0, (int)cs);
}
ssh_time_measure_stop(timer);
sec = (double)ssh_time_measure_get(timer, SSH_TIME_GRANULARITY_SECOND);
if (sec < CIPHER_TEST_MIN_TIME)
{
if (sec < 0.1)
{
/* This doesn't directly aim to sufficient length.
Let's retry with 10 times longer data to get
hash code into the cache for the `real test'. */
len_mul = 10;
}
else
{
/* Let's try to heuristically adjust the next test
loop so that it takes about CIPHER_TEST_MIN_TIME
seconds to complete. */
len_mul = (int)((CIPHER_TEST_MIN_TIME + 1.0) / sec) + 1;
}
SSH_DEBUG(5, ("Test completes too fast (%.2f sec).", sec));
SSH_DEBUG(5, ("Multiply test len by %d.", len_mul));
tot *= len_mul;
goto timer_retry;
}
else
{
SSH_DEBUG(5, ("Test completes OK (%.2f sec).", sec));
}
printf("Speed[\"%s\"] = %.2f kB (%.2f megabits) / sec\n",
cipher_name,
((((double)tot) / 1024.0) / sec),
((((double)tot) / 131072.0) / sec));
ssh_time_measure_free(timer);
ssh_cipher_free(cipher);
ssh_xfree(data);
ssh_xfree(data_dest);
return;
}
int main()
{
SshTimeMeasure total_timer;
SshTimeMeasure timer_1;
SshTimeMeasure timer_2;
SshTimeMeasure timer_3;
SshTimeMeasure timer_4;
SshTimeMeasure timer_5;
static struct SshTimeMeasureRec timer_6_rec = SSH_TIME_MEASURE_INITIALIZER;
SshTimeMeasure timer_6;
int i;
double rv = 0.0;
int ev = 0;
#ifdef HAVE_GETTIMEOFDAY
struct timeval tv;
#endif /* HAVE_GETTIMEOFDAY */
SshUInt64 seconds;
SshUInt32 nanoseconds;
total_timer = ssh_time_measure_allocate();
timer_1 = ssh_time_measure_allocate();
timer_2 = ssh_time_measure_allocate();
timer_3 = ssh_time_measure_allocate();
timer_4 = ssh_time_measure_allocate();
timer_5 = ssh_time_measure_allocate();
timer_6 = &timer_6_rec;
if (ssh_time_measure_get(timer_5, SSH_TIME_GRANULARITY_NANOSECOND) != 0)
{
ssh_warning("Weird initial stamp value.\n");
ev++;
}
if (ssh_time_measure_get(timer_6, SSH_TIME_GRANULARITY_NANOSECOND) != 0)
{
ssh_warning("Weird initial (static) stamp value.\n");
ev++;
}
rv = (double)ssh_time_measure_get(total_timer, SSH_TIME_GRANULARITY_SECOND);
if ((rv < 0.0) || (rv > 0.0))
{
ssh_warning("Weird initial value.\n");
ev++;
}
ssh_time_measure_granularity(&seconds, &nanoseconds);
if ((seconds == 0) && (nanoseconds == 0))
{
ssh_warning("Weird granularity.\n");
ev++;
}
else
{
printf("granularity is %lu sec %lu nsec\n",
(unsigned long)seconds,
(unsigned long)nanoseconds);
}
START(total_timer);
START(timer_1);
START(timer_3);
START(timer_4);
START(timer_5);
STAMP(total_timer);
printf("testing stamps\n");
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(2000000);
STAMP(total_timer);
SET(timer_5, 12345, 12345678);
INTERMEDIATE(timer_5);
if ((rv < 12345.0) || (rv > 12350.0))
{
ssh_warning("Weird intermediate after running set.\n");
ev++;
}
INTERMEDIATE(timer_1);
if (rv < 1.0)
{
ssh_warning("Weird intermediate.\n");
ev++;
}
STOP(timer_3);
if (rv < 1.0)
{
ssh_warning("Weird stop value.\n");
ev++;
}
START(timer_2);
RESET(timer_4);
USLEEP(3000000);
STAMP(total_timer);
INTERMEDIATE(timer_2);
INTERMEDIATE(timer_5);
START(timer_3);
if (rv < 1.0)
{
ssh_warning("Weird restart value.\n");
ev++;
}
RESET(timer_4);
STOP(timer_1);
USLEEP(4000000);
STAMP(total_timer);
STOP(timer_5);
#ifdef SSHUINT64_IS_64BITS
printf("Setting timer_5 to big value.\n");
ssh_time_measure_set_value(timer_5,
((SshUInt64)0xffffffff) * ((SshUInt64)30),
987654321);
INTERMEDIATE(timer_5);
if ((rv < 128849018000.0) || (rv > 128849019000.0))
{
ssh_warning("Weird intermediate after stopped set.\n");
ev++;
}
#else
SET(timer_5, 1234567890, 987654321);
INTERMEDIATE(timer_5);
if ((rv < 1234567890.0) || (rv > 1234567900.0))
{
ssh_warning("Weird intermediate after stopped set.\n");
ev++;
}
#endif
STOP(timer_4);
STOP(timer_3);
STOP(timer_2);
STOP(timer_1);
#define TIMESTAMPS 1000000
ssh_time_measure_reset(timer_1);
ssh_time_measure_reset(timer_2);
printf("\nGenerating %d timestamps.\n", TIMESTAMPS);
START(timer_2);
START(timer_1);
for (i = 1; i < TIMESTAMPS; i++)
{
ssh_time_measure_stamp(timer_2, SSH_TIME_GRANULARITY_MICROSECOND);
}
STOP(timer_1);
STOP(timer_2);
printf("Time elapsed %.12f seconds (%.12f seconds/timestamp",
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND),
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) / (double)TIMESTAMPS);
if ((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) > 0.0)
printf(", %d timestamps/second",
(int)((double)TIMESTAMPS / (double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND)));
printf(")\n");
ssh_time_measure_reset(timer_3);
ssh_time_measure_reset(timer_4);
printf("\nFor reference generating %d timestamps with time(3).\n",
TIMESTAMPS);
START(timer_4);
START(timer_3);
for (i = 1; i < TIMESTAMPS; i++)
{
ssh_time();
}
STOP(timer_3);
STOP(timer_4);
printf("Time elapsed %.12f seconds (%.12f seconds/timestamp",
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND),
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) / (double)TIMESTAMPS);
if ((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0)
printf(", %d timestamps/second",
(int)((double)TIMESTAMPS / (double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)));
printf(")\n");
if (((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) > 0.0) &&
((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0))
printf("Using time(3) is %2.1f%% faster than ssh_..._stamp.\n",
(((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) -
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)) /
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND)) * 100.0);
#ifdef HAVE_GETTIMEOFDAY
ssh_time_measure_reset(timer_3);
ssh_time_measure_reset(timer_4);
printf("\nFor reference generating %d timestamps with gettimeofday.\n",
TIMESTAMPS);
START(timer_4);
START(timer_3);
for (i = 1; i < TIMESTAMPS; i++)
{
gettimeofday(&tv, NULL);
}
STOP(timer_3);
STOP(timer_4);
printf("Time elapsed %.12f seconds (%.12f seconds/timestamp",
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND),
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) / (double)TIMESTAMPS);
if ((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0)
printf(", %d timestamps/second",
(int)((double)TIMESTAMPS / (double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)));
printf(")\n");
if (((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) > 0.0) &&
((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0))
printf("Using gettimeofday(3) is %2.1f%% faster than ssh_..._stamp.\n",
(((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) -
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)) /
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND)) * 100.0);
#endif /* HAVE_GETTIMEOFDAY */
printf("making start stop test. timers are silently started and stopped.\n");
printf("timer_3 runs while timer_4 is started and stopped in loop.\n");
ssh_time_measure_stop(timer_3);
ssh_time_measure_stop(timer_4);
ssh_time_measure_reset(timer_3);
ssh_time_measure_reset(timer_4);
ssh_time_measure_start(timer_3);
for (i = 0; i < 1000000; i++)
{
ssh_time_measure_start(timer_4);
ssh_time_measure_stop(timer_4);
}
ssh_time_measure_stop(timer_3);
INTERMEDIATE(timer_4);
INTERMEDIATE(timer_3);
STOP(total_timer);
GET_INT(timer_1);
INTERMEDIATE(timer_1);
GET_INT(timer_2);
INTERMEDIATE(timer_2);
GET_INT(timer_3);
INTERMEDIATE(timer_3);
GET_INT(timer_4);
INTERMEDIATE(timer_4);
GET_INT(timer_5);
INTERMEDIATE(timer_5);
GET_INT(total_timer);
INTERMEDIATE(total_timer);
printf("Testing granularities\n");
GET_NANOSECONDS(total_timer);
GET_MICROSECONDS(total_timer);
GET_MILLISECONDS(total_timer);
GET_SECONDS(total_timer);
GET_MINUTES(total_timer);
GET_HOURS(total_timer);
GET_DAYS(total_timer);
GET_WEEKS(total_timer);
GET_MONTHS(total_timer);
GET_YEARS(total_timer);
GET_NANOSECONDS(timer_5);
GET_MICROSECONDS(timer_5);
GET_MILLISECONDS(timer_5);
GET_SECONDS(timer_5);
GET_MINUTES(timer_5);
GET_HOURS(timer_5);
GET_DAYS(timer_5);
GET_WEEKS(timer_5);
GET_MONTHS(timer_5);
GET_MONTHS_2(timer_5);
GET_YEARS(timer_5);
GET_YEARS_2(timer_5);
GET_YEARS_3(timer_5);
ssh_time_measure_free(timer_5);
ssh_time_measure_free(timer_4);
ssh_time_measure_free(timer_3);
ssh_time_measure_free(timer_2);
ssh_time_measure_free(timer_1);
ssh_time_measure_free(total_timer);
exit(ev);
}
