diff options
Diffstat (limited to 'apps')
-rw-r--r-- | apps/speed.c | 1518 |
1 files changed, 1064 insertions, 454 deletions
diff --git a/apps/speed.c b/apps/speed.c index 97d8e5617f..80c76382e9 100644 --- a/apps/speed.c +++ b/apps/speed.c @@ -86,6 +86,7 @@ #include <openssl/err.h> #include <openssl/evp.h> #include <openssl/objects.h> +#include <openssl/async.h> #if !defined(OPENSSL_SYS_MSDOS) # include OPENSSL_UNISTD #endif @@ -98,6 +99,24 @@ # include <windows.h> #endif +#if defined(OPENSSL_SYS_UNIX) && defined(OPENSSL_THREADS) +# include <unistd.h> +#endif + +#if !defined(OPENSSL_NO_ASYNC) +# if defined(OPENSSL_SYS_UNIX) && defined(OPENSSL_THREADS) +# if _POSIX_VERSION >= 200112L +# define ASYNC_POSIX +# endif +# elif defined(_WIN32) || defined(__CYGWIN__) +# define ASYNC_WIN +# endif +#endif + +#if !defined(ASYNC_POSIX) && !defined(ASYNC_WIN) +# define ASYNC_NULL +#endif + #include <openssl/bn.h> #ifndef OPENSSL_NO_DES # include <openssl/des.h> @@ -178,7 +197,7 @@ #endif #undef BUFSIZE -#define BUFSIZE (1024*8+1) +#define BUFSIZE (1024*16+1) #define MAX_MISALIGNMENT 63 static volatile int run = 0; @@ -186,6 +205,75 @@ static volatile int run = 0; static int mr = 0; static int usertime = 1; +typedef struct loopargs_st { + ASYNC_JOB *inprogress_job; + unsigned char *buf; + unsigned char *buf2; + unsigned char *buf_malloc; + unsigned char *buf2_malloc; + EVP_CIPHER_CTX *ctx; + HMAC_CTX *hctx; + GCM128_CONTEXT *gcm_ctx; + unsigned char ecdsasig[256]; + unsigned int siglen; +} loopargs_t; + +#ifndef OPENSSL_NO_MD2 +static int EVP_Digest_MD2_loop(void *args); +#endif + +#ifndef OPENSSL_NO_MDC2 +static int EVP_Digest_MDC2_loop(void *args); +#endif +#ifndef OPENSSL_NO_MD4 +static int EVP_Digest_MD4_loop(void *args); +#endif +#ifndef OPENSSL_NO_MD5 +static int MD5_loop(void *args); +static int HMAC_loop(void *args); +#endif +static int SHA1_loop(void *args); +static int SHA256_loop(void *args); +static int SHA512_loop(void *args); +#ifndef OPENSSL_NO_WHIRLPOOL +static int WHIRLPOOL_loop(void *args); +#endif +#ifndef OPENSSL_NO_RMD160 +static int EVP_Digest_RMD160_loop(void *args); +#endif +#ifndef OPENSSL_NO_RC4 +static int RC4_loop(void *args); +#endif +#ifndef OPENSSL_NO_DES +static int DES_ncbc_encrypt_loop(void *args); +static int DES_ede3_cbc_encrypt_loop(void *args); +#endif +#ifndef OPENSSL_NO_AES +static int AES_cbc_128_encrypt_loop(void *args); +static int AES_cbc_192_encrypt_loop(void *args); +static int AES_ige_128_encrypt_loop(void *args); +static int AES_cbc_256_encrypt_loop(void *args); +static int AES_ige_192_encrypt_loop(void *args); +static int AES_ige_256_encrypt_loop(void *args); +static int CRYPTO_gcm128_aad_loop(void *args); +#endif +static int EVP_Update_loop(void *args); +static int EVP_Digest_loop(void *args); +#ifndef OPENSSL_NO_RSA +static int RSA_sign_loop(void *args); +static int RSA_verify_loop(void *args); +#endif +#ifndef OPENSSL_NO_DSA +static int DSA_sign_loop(void *args); +static int DSA_verify_loop(void *args); +#endif +#ifndef OPENSSL_NO_EC +static int ECDSA_sign_loop(void *args); +static int ECDSA_verify_loop(void *args); +static int ECDH_compute_key_loop(void *args); +#endif +static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs); + static double Time_F(int s); static void print_message(const char *s, long num, int length); static void pkey_print_message(const char *str, const char *str2, @@ -196,7 +284,7 @@ static int do_multi(int multi); #endif #define ALGOR_NUM 30 -#define SIZE_NUM 5 +#define SIZE_NUM 6 #define PRIME_NUM 3 #define RSA_NUM 7 #define DSA_NUM 3 @@ -217,7 +305,7 @@ static const char *names[ALGOR_NUM] = { static double results[ALGOR_NUM][SIZE_NUM]; static int lengths[SIZE_NUM] = { - 16, 64, 256, 1024, 8 * 1024 + 16, 64, 256, 1024, 8 * 1024, 16 * 1024 }; #ifndef OPENSSL_NO_RSA @@ -339,7 +427,7 @@ static int found(const char *name, const OPT_PAIR * pairs, int *result) typedef enum OPTION_choice { OPT_ERR = -1, OPT_EOF = 0, OPT_HELP, OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI, - OPT_MR, OPT_MB, OPT_MISALIGN + OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS } OPTION_CHOICE; OPTIONS speed_options[] = { @@ -357,6 +445,9 @@ OPTIONS speed_options[] = { #ifndef NO_FORK {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"}, #endif +#ifndef ASYNC_NULL + {"async_jobs", OPT_ASYNCJOBS, 'p', "Enable async mode and start pnum jobs"}, +#endif #ifndef OPENSSL_NO_ENGINE {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"}, #endif @@ -552,51 +643,607 @@ static OPT_PAIR ecdh_choices[] = { }; #endif -int speed_main(int argc, char **argv) -{ - char *prog; - const EVP_CIPHER *evp_cipher = NULL; - const EVP_MD *evp_md = NULL; - double d = 0.0; - OPTION_CHOICE o; - int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0; - int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM]; - int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1; - long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0; - unsigned char *buf_malloc = NULL, *buf2_malloc = NULL; - unsigned char *buf = NULL, *buf2 = NULL; - unsigned char md[EVP_MAX_MD_SIZE]; -#ifndef NO_FORK - int multi = 0; -#endif - /* What follows are the buffers and key material. */ -#if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) - long rsa_count; -#endif +#ifndef SIGALRM +# define COND(d) (count < (d)) +# define COUNT(d) (d) +#else +# define COND(c) (run && count<0x7fffffff) +# define COUNT(d) (count) +#endif /* SIGALRM */ + +static int testnum; +static char *engine_id = NULL; + + #ifndef OPENSSL_NO_MD2 +static int EVP_Digest_MD2_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char md2[MD2_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_MD2][testnum]); count++) + EVP_Digest(buf, (unsigned long)lengths[testnum], &(md2[0]), NULL, + EVP_md2(), NULL); + return count; +} #endif + #ifndef OPENSSL_NO_MDC2 +static int EVP_Digest_MDC2_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char mdc2[MDC2_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_MDC2][testnum]); count++) + EVP_Digest(buf, (unsigned long)lengths[testnum], &(mdc2[0]), NULL, + EVP_mdc2(), NULL); + return count; +} #endif + #ifndef OPENSSL_NO_MD4 +static int EVP_Digest_MD4_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char md4[MD4_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_MD4][testnum]); count++) + EVP_Digest(&(buf[0]), (unsigned long)lengths[testnum], &(md4[0]), + NULL, EVP_md4(), NULL); + return count; +} #endif + #ifndef OPENSSL_NO_MD5 +static int MD5_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char md5[MD5_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_MD5][testnum]); count++) + MD5(buf, lengths[testnum], md5); + return count; +} + +static int HMAC_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + HMAC_CTX *hctx = tempargs->hctx; unsigned char hmac[MD5_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_HMAC][testnum]); count++) { + HMAC_Init_ex(hctx, NULL, 0, NULL, NULL); + HMAC_Update(hctx, buf, lengths[testnum]); + HMAC_Final(hctx, &(hmac[0]), NULL); + } + return count; +} #endif + +static int SHA1_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char sha[SHA_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_SHA1][testnum]); count++) + SHA1(buf, lengths[testnum], sha); + return count; +} + +static int SHA256_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char sha256[SHA256_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_SHA256][testnum]); count++) + SHA256(buf, lengths[testnum], sha256); + return count; +} + +static int SHA512_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char sha512[SHA512_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_SHA512][testnum]); count++) + SHA512(buf, lengths[testnum], sha512); + return count; +} + #ifndef OPENSSL_NO_WHIRLPOOL +static int WHIRLPOOL_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++) + WHIRLPOOL(buf, lengths[testnum], whirlpool); + return count; +} #endif + #ifndef OPENSSL_NO_RMD160 +static int EVP_Digest_RMD160_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; unsigned char rmd160[RIPEMD160_DIGEST_LENGTH]; + int count; + for (count = 0; COND(c[D_RMD160][testnum]); count++) + EVP_Digest(buf, (unsigned long)lengths[testnum], &(rmd160[0]), NULL, + EVP_ripemd160(), NULL); + return count; +} #endif + #ifndef OPENSSL_NO_RC4 - RC4_KEY rc4_ks; +static RC4_KEY rc4_ks; +static int RC4_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + int count; + for (count = 0; COND(c[D_RC4][testnum]); count++) + RC4(&rc4_ks, (unsigned int)lengths[testnum], buf, buf); + return count; +} +#endif + +#ifndef OPENSSL_NO_DES +static unsigned char DES_iv[8]; +static DES_key_schedule sch; +static DES_key_schedule sch2; +static DES_key_schedule sch3; +static int DES_ncbc_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + int count; + for (count = 0; COND(c[D_CBC_DES][testnum]); count++) + DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch, + &DES_iv, DES_ENCRYPT); + return count; +} + +static int DES_ede3_cbc_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + int count; + for (count = 0; COND(c[D_EDE3_DES][testnum]); count++) + DES_ede3_cbc_encrypt(buf, buf, lengths[testnum], + &sch, &sch2, &sch3, + &DES_iv, DES_ENCRYPT); + return count; +} +#endif + +#ifndef OPENSSL_NO_AES +# define MAX_BLOCK_SIZE 128 +#else +# define MAX_BLOCK_SIZE 64 +#endif + +static unsigned char iv[2 * MAX_BLOCK_SIZE / 8]; +#ifndef OPENSSL_NO_AES +static AES_KEY aes_ks1, aes_ks2, aes_ks3; +static int AES_cbc_128_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + int count; + for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++) + AES_cbc_encrypt(buf, buf, + (unsigned long)lengths[testnum], &aes_ks1, + iv, AES_ENCRYPT); + return count; +} + +static int AES_cbc_192_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + int count; + for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++) + AES_cbc_encrypt(buf, buf, + (unsigned long)lengths[testnum], &aes_ks2, + iv, AES_ENCRYPT); + return count; +} + +static int AES_cbc_256_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + int count; + for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++) + AES_cbc_encrypt(buf, buf, + (unsigned long)lengths[testnum], &aes_ks3, + iv, AES_ENCRYPT); + return count; +} + +static int AES_ige_128_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *buf2 = tempargs->buf2; + int count; + for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++) + AES_ige_encrypt(buf, buf2, + (unsigned long)lengths[testnum], &aes_ks1, + iv, AES_ENCRYPT); + return count; +} + +static int AES_ige_192_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *buf2 = tempargs->buf2; + int count; + for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++) + AES_ige_encrypt(buf, buf2, + (unsigned long)lengths[testnum], &aes_ks2, + iv, AES_ENCRYPT); + return count; +} + +static int AES_ige_256_encrypt_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *buf2 = tempargs->buf2; + int count; + for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++) + AES_ige_encrypt(buf, buf2, + (unsigned long)lengths[testnum], &aes_ks3, + iv, AES_ENCRYPT); + return count; +} + +static int CRYPTO_gcm128_aad_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx; + int count; + for (count = 0; COND(c[D_GHASH][testnum]); count++) + CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]); + return count; +} + +#endif + +static int decrypt = 0; +static int EVP_Update_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + EVP_CIPHER_CTX *ctx = tempargs->ctx; + int outl, count; + if (decrypt) + for (count = 0; + COND(save_count * 4 * lengths[0] / lengths[testnum]); + count++) + EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]); + else + for (count = 0; + COND(save_count * 4 * lengths[0] / lengths[testnum]); + count++) + EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]); + if (decrypt) + EVP_DecryptFinal_ex(ctx, buf, &outl); + else + EVP_EncryptFinal_ex(ctx, buf, &outl); + return count; +} + +static const EVP_MD *evp_md = NULL; +static int EVP_Digest_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char md[EVP_MAX_MD_SIZE]; + int count; + for (count = 0; + COND(save_count * 4 * lengths[0] / lengths[testnum]); count++) + EVP_Digest(buf, lengths[testnum], &(md[0]), NULL, evp_md, NULL); + + return count; +} + +#ifndef OPENSSL_NO_RSA +static unsigned rsa_num; +static RSA *rsa_key[RSA_NUM]; +static long rsa_c[RSA_NUM][2]; + +static int RSA_sign_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *buf2 = tempargs->buf2; + int ret, count; + for (count = 0; COND(rsa_c[testnum][0]); count++) { + ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[testnum]); + if (ret == 0) { + BIO_printf(bio_err, "RSA sign failure\n"); + ERR_print_errors(bio_err); + count = -1; + break; + } + } + return count; +} + +static int RSA_verify_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *buf2 = tempargs->buf2; + int ret, count; + for (count = 0; COND(rsa_c[testnum][1]); count++) { + ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]); + if (ret <= 0) { + BIO_printf(bio_err, "RSA verify failure\n"); + ERR_print_errors(bio_err); + count = -1; + break; + } + } + return count; +} +#endif + +#ifndef OPENSSL_NO_DSA +static DSA *dsa_key[DSA_NUM]; +static long dsa_c[DSA_NUM][2]; +static int DSA_sign_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *buf2 = tempargs->buf2; + unsigned int *siglen = &(tempargs->siglen); + int ret, count; + for (count = 0; COND(dsa_c[testnum][0]); count++) { + ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]); + if (ret == 0) { + BIO_printf(bio_err, "DSA sign failure\n"); + ERR_print_errors(bio_err); + count = 1; + break; + } + } + return count; +} + +static int DSA_verify_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *buf2 = tempargs->buf2; + unsigned int siglen = tempargs->siglen; + int ret, count; + for (count = 0; COND(dsa_c[testnum][1]); count++) { + ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]); + if (ret <= 0) { + BIO_printf(bio_err, "DSA verify failure\n"); + ERR_print_errors(bio_err); + count = 1; + break; + } + } + return count; +} +#endif + +#ifndef OPENSSL_NO_EC +static EC_KEY *ecdsa[EC_NUM]; +static long ecdsa_c[EC_NUM][2]; +static int ECDSA_sign_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *ecdsasig = tempargs->ecdsasig; + unsigned int *ecdsasiglen = &(tempargs->siglen); + int ret, count; + for (count = 0; COND(ecdsa_c[testnum][0]); count++) { + ret = ECDSA_sign(0, buf, 20, + ecdsasig, ecdsasiglen, ecdsa[testnum]); + if (ret == 0) { + BIO_printf(bio_err, "ECDSA sign failure\n"); + ERR_print_errors(bio_err); + count = 1; + break; + } + } + return count; +} + +static int ECDSA_verify_loop(void *args) +{ + loopargs_t *tempargs = (loopargs_t *)args; + unsigned char *buf = tempargs->buf; + unsigned char *ecdsasig = tempargs->ecdsasig; + unsigned int ecdsasiglen = tempargs->siglen; + int ret, count; + for (count = 0; COND(ecdsa_c[testnum][1]); count++) { + ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, + ecdsa[testnum]); + if (ret != 1) { + BIO_printf(bio_err, "ECDSA verify failure\n"); + ERR_print_errors(bio_err); + count = 1; + break; + } + } + return count; +} + +static unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE]; +static EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM]; +static int outlen; +static void *(*kdf) (const void *in, size_t inlen, void *out, + size_t *xoutlen); + +static int ECDH_compute_key_loop(void *args) +{ + int count; + for (count = 0; COND(ecdh_c[testnum][0]); count++) { + ECDH_compute_key(secret_a, outlen, + EC_KEY_get0_public_key(ecdh_b[testnum]), + ecdh_a[testnum], kdf); + } + return count; +} +#endif + + +static int run_benchmark(int async_jobs, int (*loop_function)(void *), loopargs_t *loopargs) +{ + int job_op_count = 0; + int total_op_count = 0; + int num_inprogress = 0; + int error = 0; + int i = 0; + + run = 1; + + if (0 == async_jobs) { + return loop_function((void *)loopargs); + } + + for (i = 0; i < async_jobs && !error; i++) { + switch (ASYNC_start_job(&(loopargs[i].inprogress_job), &job_op_count, + loop_function, (void *)(loopargs + i), sizeof(loopargs_t))) { + case ASYNC_PAUSE: + ++num_inprogress; + break; + case ASYNC_FINISH: + if (job_op_count == -1) { + error = 1; + } else { + total_op_count += job_op_count; + } + break; + case ASYNC_NO_JOBS: + case ASYNC_ERR: + BIO_printf(bio_err, "Failure in the job\n"); + ERR_print_errors(bio_err); + error = 1; + break; + } + } + + while (num_inprogress > 0) { + OSSL_ASYNC_FD job_fd = 0; +#if defined(ASYNC_POSIX) + OSSL_ASYNC_FD max_fd = 0; + int select_result = 0; + fd_set waitfdset; + struct timeval select_timeout; + FD_ZERO(&waitfdset); + select_timeout.tv_sec=0; + select_timeout.tv_usec=0; + + for (i = 0; i < async_jobs; i++) { + if (loopargs[i].inprogress_job != NULL) { + job_fd = ASYNC_get_wait_fd(loopargs[i].inprogress_job); + FD_SET(job_fd, &waitfdset); + if (job_fd > max_fd) + max_fd = job_fd; + } + } + select_result = select(max_fd + 1, &waitfdset, NULL, NULL, &select_timeout); + + if (select_result == -1 && errno == EINTR) + continue; + + if (select_result == -1) { + BIO_printf(bio_err, "Failure in the select\n"); + ERR_print_errors(bio_err); + error = 1; + break; + } + + if (select_result == 0) + continue; + +#elif defined(ASYNC_WIN) + DWORD avail = 0; +#endif + + for (i = 0; i < async_jobs; i++) { + if (loopargs[i].inprogress_job == NULL) + continue; + + job_fd = ASYNC_get_wait_fd(loopargs[i].inprogress_job); + +#if defined(ASYNC_POSIX) + if (!FD_ISSET(job_fd, &waitfdset)) + continue; +#elif defined(ASYNC_WIN) + if (!PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL) && avail > 0) + continue; +#endif + + switch (ASYNC_start_job(&(loopargs[i].inprogress_job), + &job_op_count, loop_function, (void *)(loopargs + i), + sizeof(loopargs_t))) { + case ASYNC_PAUSE: + break; + case ASYNC_FINISH: + if (job_op_count == -1) { + error = 1; + } else { + total_op_count += job_op_count; + } + --num_inprogress; + loopargs[i].inprogress_job = NULL; + break; + case ASYNC_NO_JOBS: + case ASYNC_ERR: + --num_inprogress; + loopargs[i].inprogress_job = NULL; + BIO_printf(bio_err, "Failure in the job\n"); + ERR_print_errors(bio_err); + error = 1; + break; + } + } + } + + return error ? -1 : total_op_count; +} + +int speed_main(int argc, char **argv) +{ + loopargs_t *loopargs = NULL; + int loopargs_len = 0; + char *prog; + const EVP_CIPHER *evp_cipher = NULL; + double d = 0.0; + OPTION_CHOICE o; + int multiblock = 0, doit[ALGOR_NUM], pr_header = 0; + int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM]; + int ret = 1, i, k, misalign = 0; + long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0; +#ifndef NO_FORK + int multi = 0; +#endif + int async_jobs = 0; + /* What follows are the buffers and key material. */ +#if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) + long rsa_count; #endif #ifndef OPENSSL_NO_RC5 RC5_32_KEY rc5_ks; @@ -647,13 +1294,6 @@ int speed_main(int argc, char **argv) }; CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3; #endif -#ifndef OPENSSL_NO_AES -# define MAX_BLOCK_SIZE 128 -#else -# define MAX_BLOCK_SIZE 64 -#endif - unsigned char DES_iv[8]; - unsigned char iv[2 * MAX_BLOCK_SIZE / 8]; #ifndef OPENSSL_NO_DES static DES_cblock key = { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 @@ -664,17 +1304,8 @@ int speed_main(int argc, char **argv) static DES_cblock key3 = { 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34 }; - DES_key_schedule sch; - DES_key_schedule sch2; - DES_key_schedule sch3; -#endif -#ifndef OPENSSL_NO_AES - AES_KEY aes_ks1, aes_ks2, aes_ks3; #endif #ifndef OPENSSL_NO_RSA - unsigned rsa_num; - RSA *rsa_key[RSA_NUM]; - long rsa_c[RSA_NUM][2]; static unsigned int rsa_bits[RSA_NUM] = { 512, 1024, 2048, 3072, 4096, 7680, 15360 }; @@ -689,8 +1320,6 @@ int speed_main(int argc, char **argv) }; #endif #ifndef OPENSSL_NO_DSA - DSA *dsa_key[DSA_NUM]; - long dsa_c[DSA_NUM][2]; static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 }; #endif #ifndef OPENSSL_NO_EC @@ -733,13 +1362,7 @@ int speed_main(int argc, char **argv) }; #endif #ifndef OPENSSL_NO_EC - unsigned char ecdsasig[256]; - unsigned int ecdsasiglen; - EC_KEY *ecdsa[EC_NUM]; - long ecdsa_c[EC_NUM][2]; int ecdsa_doit[EC_NUM]; - EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM]; - unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE]; int secret_size_a, secret_size_b; int ecdh_checks = 0; int secret_idx = 0; @@ -780,8 +1403,6 @@ int speed_main(int argc, char **argv) ecdh_doit[i] = 0; #endif - buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer"); - buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer"); misalign = 0; prog = opt_init(argc, argv, speed_options); @@ -815,13 +1436,23 @@ int speed_main(int argc, char **argv) decrypt = 1; break; case OPT_ENGINE: - (void)setup_engine(opt_arg(), 0); + /* + * In a forked execution, an engine might need to be + * initialised by each child process, not by the parent. + * So store the name here and run setup_engine() later on. + */ + engine_id = opt_arg(); break; case OPT_MULTI: #ifndef NO_FORK multi = atoi(opt_arg()); #endif break; + case OPT_ASYNCJOBS: +#ifndef ASYNC_NULL + async_jobs = atoi(opt_arg()); +#endif + break; case OPT_MISALIGN: if (!opt_int(opt_arg(), &misalign)) goto end; @@ -830,8 +1461,6 @@ int speed_main(int argc, char **argv) "%s: Maximum offset is %d\n", prog, MISALIGN); goto opterr; } - buf = buf_malloc + misalign; - buf2 = buf2_malloc + misalign; break; case OPT_MR: mr = 1; @@ -928,11 +1557,34 @@ int speed_main(int argc, char **argv) goto end; } + /* Initialize the job pool if async mode is enabled */ + if (async_jobs > 0) { + if (!ASYNC_init_thread(async_jobs, async_jobs)) { + BIO_printf(bio_err, "Error creating the ASYNC job pool\n"); + goto end; + } + } + + loopargs_len = (async_jobs == 0 ? 1 : async_jobs); + loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs"); + memset(loopargs, 0, loopargs_len * sizeof(loopargs_t)); + + for (i = 0; i < loopargs_len; ++i) { + loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer"); + loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer"); + /* Align the start of buffers on a 64 byte boundary */ + loopargs[i].buf = loopargs[i].buf_malloc + misalign; + loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign; + } + #ifndef NO_FORK if (multi && do_multi(multi)) goto show_res; #endif + /* Initialize the engine after the fork */ + (void)setup_engine(engine_id, 0); + /* No parameters; turn on everything. */ if ((argc == 0) && !doit[D_EVP]) { for (i = 0; i < ALGOR_NUM; i++) @@ -1026,8 +1678,8 @@ int speed_main(int argc, char **argv) count *= 2; Time_F(START); for (it = count; it; it--) - DES_ecb_encrypt((DES_cblock *)buf, - (DES_cblock *)buf, &sch, DES_ENCRYPT); + DES_ecb_encrypt((DES_cblock *)loopargs[0].buf, + (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT); d = Time_F(STOP); } while (d < 3); save_count = count; @@ -1223,15 +1875,11 @@ int speed_main(int argc, char **argv) } # endif -# define COND(d) (count < (d)) -# define COUNT(d) (d) # else /* not worth fixing */ # error "You cannot disable DES on systems without SIGALRM." # endif /* OPENSSL_NO_DES */ #else -# define COND(c) (run && count<0x7fffffff) -# define COUNT(d) (count) # ifndef _WIN32 signal(SIGALRM, sig_done); # endif @@ -1239,396 +1887,394 @@ int speed_main(int argc, char **argv) #ifndef OPENSSL_NO_MD2 if (doit[D_MD2]) { - for (j = 0; j < SIZE_NUM; j++) { - print_message(names[D_MD2], c[D_MD2][j], lengths[j]); + for (testnum = 0; testnum < SIZE_NUM; testnum++) { + print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]); Time_F(START); - for (count = 0, run = 1; COND(c[D_MD2][j]); count++) - EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL, - EVP_md2(), NULL); + count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs); d = Time_F(STOP); - print_result(D_MD2, j, count, d); + print_result(D_MD2, testnum, count, d); } } #endif #ifndef OPENSSL_NO_MDC2 if (doit[D_MDC2]) { - for (j = 0; j < SIZE_NUM; j++) { - print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]); + for (testnum = 0; testnum < SIZE_NUM; testnum++) { + print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]); Time_F(START); - for (count = 0, run = 1; COND(c[D_MDC2][j]); count++) - EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL, - EVP_mdc2(), NULL); + count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs); d = Time_F(STOP); - print_result(D_MDC2, j, count, d); + print_result(D_MDC2, testnum, count, d); } } #endif #ifndef OPENSSL_NO_MD4 if (doit[D_MD4]) { - for (j = 0; j < SIZE_NUM; j++) { - print_message(names[D_MD4], c[D_MD4][j], lengths[j]); + for (testnum = 0; testnum < SIZE_NUM; testnum++) { + print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]); Time_F(START); - for (count = 0, run = 1; COND(c[D_MD4][j]); count++) - EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]), - NULL, EVP_md4(), NULL); + count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs); d = Time_F(STOP); - print_result(D_MD4, j, count, d); + print_result(D_MD4, testnum, count, d); } } #endif #ifndef OPENSSL_NO_MD5 if (doit[D_MD5]) { - for (j = 0; j < SIZE_NUM; j++) { - print_message(names[D_MD5], c[D_MD5][j], lengths[j]); + for (testnum = 0; testnum < SIZE_NUM; testnum++) { + print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]); Time_F(START); - for (count = 0, run = 1; COND(c[D_MD5][j]); count++) - MD5(buf, lengths[j], md5); + count = run_benchmark(async_jobs, MD5_loop, loopargs); d = Time_F(STOP); - print_result(D_MD5, j, count, d); + print_result(D_MD5, testnum, count, d); } } #endif -#if !defined(OPENSSL_NO_MD5) +#ifndef OPENSSL_NO_MD5 if (doit[D_HMAC]) { - HMAC_CTX *hctx = NULL; + for (i = 0; i < loopargs_len; ++i) { + loopargs[i].hctx = HMAC_CTX_new(); + if (loopargs[i].hctx == NULL) { + BIO_printf(bio_err, "HMAC malloc failure, exiting..."); + exit(1); + } - hctx = HMAC_CTX_new(); - if (hctx == NULL) { - BIO_printf(bio_err, "HMAC malloc failure, exiting..."); - exit(1); + HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...", + 16, EVP_md5(), NULL); } - HMAC_Init_ex(hctx, (unsigned char *)"This is a key...", - 16, EVP_md5(), NULL); - - for (j = 0; j < SIZE_NUM; j++) { - print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]); + for (testnum = 0; testnum < SIZE_NUM; testnum++) { + print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]); Time_F(START); - for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) { - HMAC_Init_ex(hctx, NULL, 0, NULL, NULL); - HMAC_Update(hctx, buf, lengths[j]); - HMAC_Final(hctx, &(hmac[0]), NULL); - } + count = run_benchmark(async_jobs, HMAC_loop, loopargs); d = Time_F(STOP); - print_result(D_HMAC, j, count, d); + print_result(D_HMAC, testnum, count, d); + } + for (i = 0; i < loopargs_len; ++i) { + HMAC_CTX_free(loopargs[i].hctx); } - HMAC_CTX_free(hctx); } #endif if (doit[D_SHA1]) { - for (j = 0; j < SIZE_NUM; j++) { - print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]); + for (testnum = 0; testnum < SIZE_NUM; testnum++) { + print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]); Time_F(START); - for (count = 0, run = 1; COND(c[D_SHA1][j]); count++) - SHA1(buf, lengths[j], sha); + count = run_benchmark(async_jobs, SHA1_loop, loopargs); d = Time_F(STOP); - print_result(D_SHA1, j, count, d); + print_result(D_SHA1, |