review comments

Author: bigbrett

benchmark/README.md

@@ -137,6 +137,8 @@ To add a new benchmark module:
 2. Implement the benchmark module function following this pattern:
 
 ```c
+#include "benchmark/wh_bench_mod.h"
+
 int wh_Bench_Mod_NewOp(whClientContext* client, BenchOpContext* benchCtx, int id, void* params)
 {
     int ret = 0;

benchmark/bench_modules/wh_bench_mod_aes.c

@@ -41,33 +41,33 @@ enum { DECRYPT = 0, ENCRYPT = 1 };
 
 
 #if defined(HAVE_AES_ECB)
-int wh_Bench_Mod_Aes128ECBEncrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes128ECBEncrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
-    return WH_ERROR_NOT_IMPL;
+    return WH_ERROR_NOTIMPL;
 }
 
-int wh_Bench_Mod_Aes128ECBDecrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes128ECBDecrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
-    return WH_ERROR_NOT_IMPL;
+    return WH_ERROR_NOTIMPL;
 }
 
-int wh_Bench_Mod_Aes256ECBEncrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes256ECBEncrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
-    return WH_ERROR_NOT_IMPL;
+    return WH_ERROR_NOTIMPL;
 }
 
-int wh_Bench_Mod_Aes256ECBDecrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes256ECBDecrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
-    return WH_ERROR_NOT_IMPL;
+    return WH_ERROR_NOTIMPL;
 }
 #endif /* HAVE_AES_ECB */
 
 #if defined(HAVE_AES_CBC)
-static int _benchAesCbc(whClientContext* client, BenchOpContext* ctx, int id,
+static int _benchAesCbc(whClientContext* client, whBenchOpContext* ctx, int id,
                         const uint8_t* key, size_t keyLen, int encrypt)
 {
     int     ret       = 0;
@@ -168,37 +168,37 @@ static int _benchAesCbc(whClientContext* client, BenchOpContext* ctx, int id,
 }
 
 
-int wh_Bench_Mod_Aes128CBCEncrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes128CBCEncrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesCbc(client, ctx, id, (uint8_t*)key128, sizeof(key128),
                         ENCRYPT);
 }
 
-int wh_Bench_Mod_Aes128CBCDecrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes128CBCDecrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesCbc(client, ctx, id, (uint8_t*)key128, sizeof(key128),
                         DECRYPT);
 }
 
-int wh_Bench_Mod_Aes256CBCEncrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes256CBCEncrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesCbc(client, ctx, id, (uint8_t*)key256, sizeof(key256),
                         ENCRYPT);
 }
 
-int wh_Bench_Mod_Aes256CBCDecrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes256CBCDecrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesCbc(client, ctx, id, (uint8_t*)key256, sizeof(key256),
                         DECRYPT);
 }
 #endif /* HAVE_AES_CBC */
 
 #if defined(HAVE_AESGCM)
-static int _benchAesGcm(whClientContext* client, BenchOpContext* ctx, int id,
+static int _benchAesGcm(whClientContext* client, whBenchOpContext* ctx, int id,
                         const uint8_t* key, size_t keyLen, int encrypt)
 {
     int     ret       = 0;
@@ -325,29 +325,29 @@ static int _benchAesGcm(whClientContext* client, BenchOpContext* ctx, int id,
 }
 
 
-int wh_Bench_Mod_Aes128GCMEncrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes128GCMEncrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesGcm(client, ctx, id, (uint8_t*)key128, sizeof(key128),
                         ENCRYPT);
 }
 
-int wh_Bench_Mod_Aes128GCMDecrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes128GCMDecrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesGcm(client, ctx, id, (uint8_t*)key128, sizeof(key128),
                         DECRYPT);
 }
 
-int wh_Bench_Mod_Aes256GCMEncrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes256GCMEncrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesGcm(client, ctx, id, (uint8_t*)key256, sizeof(key256),
                         ENCRYPT);
 }
 
-int wh_Bench_Mod_Aes256GCMDecrypt(whClientContext* client, BenchOpContext* ctx,
-                                  int id, void* params)
+int wh_Bench_Mod_Aes256GCMDecrypt(whClientContext*  client,
+                                  whBenchOpContext* ctx, int id, void* params)
 {
     return _benchAesGcm(client, ctx, id, (uint8_t*)key256, sizeof(key256),
                         DECRYPT);