Remove memory fences where we can do better

elichai · elichai · commit a5198c52ba9f · 2019-10-22T00:30:16.000+03:00
diff --git a/src/bench.h b/src/bench.h
@@ -13,11 +13,21 @@
 #include "sys/time.h"
 
 
+# if defined(__GNUC__)
+#   define ALWAYS_INLINE SECP256K1_INLINE __attribute__((__always_inline__))
+# elif defined(_MSC_VER) && !defined(__clang__)
+#   define ALWAYS_INLINE SECP256K1_INLINE __forceinline
+# elif defined(__CLANG__) && __has_attribute(__always_inline__)
+#   define ALWAYS_INLINE SECP256K1_INLINE __attribute__((__always_inline__))
+# else
+#   define ALWAYS_INLINE SECP256K1_INLINE
+# endif
+
 /* A memory fence to prevent compiler optimizations
    It tells the optimizer that it can do whatever it wants with *p so the optimizer can't optimize *p out.
    The nice thing is that because the assembly is actually empty it doesn't add any instrcutions
    *Notice: This is a best effort, nothing promise us it will always work.* */
-static void memory_fence(void *p) {
+ALWAYS_INLINE static void memory_fence(void *p) {
     __asm__ __volatile__("": : "g"(p) : "memory");
 }
 
diff --git a/src/bench_internal.c b/src/bench_internal.c
@@ -27,7 +27,6 @@ typedef struct {
     int wnaf[256];
 } bench_inv;
 
-
 void bench_setup(void* arg) {
     bench_inv *data = (bench_inv*)arg;
 
@@ -58,13 +57,13 @@ void bench_setup(void* arg) {
 }
 
 void bench_scalar_add(void* arg) {
-    int i;
+    int i, j = 0;
     bench_inv *data = (bench_inv*)arg;
 
     for (i = 0; i < 2000000; i++) {
-        secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
-        memory_fence(data);
+        j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
     }
+    CHECK(j <= 2000000);
 }
 
 void bench_scalar_negate(void* arg) {
@@ -73,8 +72,8 @@ void bench_scalar_negate(void* arg) {
 
     for (i = 0; i < 2000000; i++) {
         secp256k1_scalar_negate(&data->scalar_x, &data->scalar_x);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_scalar_sqr(void* arg) {
@@ -83,8 +82,8 @@ void bench_scalar_sqr(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_scalar_sqr(&data->scalar_x, &data->scalar_x);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_scalar_mul(void* arg) {
@@ -93,44 +92,45 @@ void bench_scalar_mul(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_scalar_mul(&data->scalar_x, &data->scalar_x, &data->scalar_y);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 #ifdef USE_ENDOMORPHISM
 void bench_scalar_split(void* arg) {
-    int i;
+    int i, j = 0;
     bench_inv *data = (bench_inv*)arg;
 
     for (i = 0; i < 20000; i++) {
-        secp256k1_scalar l, r;
-        secp256k1_scalar_split_lambda(&l, &r, &data->scalar_x);
-        secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
-        memory_fence(data);
+        secp256k1_scalar_split_lambda(&data->scalar_x, &data->scalar_y, &data->scalar_x);
+        j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
     }
+    CHECK(j <= 2000);
 }
 #endif
 
 void bench_scalar_inverse(void* arg) {
-    int i;
+    int i, j = 0;
     bench_inv *data = (bench_inv*)arg;
 
     for (i = 0; i < 2000; i++) {
         secp256k1_scalar_inverse(&data->scalar_x, &data->scalar_x);
-        secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
-        memory_fence(data);
+        j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
     }
+    memory_fence(data);
+    CHECK(j <= 2000);
 }
 
 void bench_scalar_inverse_var(void* arg) {
-    int i;
+    int i, j = 0;
     bench_inv *data = (bench_inv*)arg;
 
     for (i = 0; i < 2000; i++) {
         secp256k1_scalar_inverse_var(&data->scalar_x, &data->scalar_x);
-        secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
-        memory_fence(data);
+        j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
     }
+    memory_fence(data);
+    CHECK(j <= 2000);
 }
 
 void bench_field_normalize(void* arg) {
@@ -139,8 +139,8 @@ void bench_field_normalize(void* arg) {
 
     for (i = 0; i < 2000000; i++) {
         secp256k1_fe_normalize(&data->fe_x);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_field_normalize_weak(void* arg) {
@@ -149,8 +149,8 @@ void bench_field_normalize_weak(void* arg) {
 
     for (i = 0; i < 2000000; i++) {
         secp256k1_fe_normalize_weak(&data->fe_x);
-        memory_fence(data);
     }
+     memory_fence(data);
 }
 
 void bench_field_mul(void* arg) {
@@ -159,8 +159,8 @@ void bench_field_mul(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_fe_mul(&data->fe_x, &data->fe_x, &data->fe_y);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_field_sqr(void* arg) {
@@ -169,8 +169,8 @@ void bench_field_sqr(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_fe_sqr(&data->fe_x, &data->fe_x);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_field_inverse(void* arg) {
@@ -180,8 +180,8 @@ void bench_field_inverse(void* arg) {
     for (i = 0; i < 20000; i++) {
         secp256k1_fe_inv(&data->fe_x, &data->fe_x);
         secp256k1_fe_add(&data->fe_x, &data->fe_y);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_field_inverse_var(void* arg) {
@@ -191,21 +191,22 @@ void bench_field_inverse_var(void* arg) {
     for (i = 0; i < 20000; i++) {
         secp256k1_fe_inv_var(&data->fe_x, &data->fe_x);
         secp256k1_fe_add(&data->fe_x, &data->fe_y);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_field_sqrt(void* arg) {
-    int i;
+    int i, j=0;
     bench_inv *data = (bench_inv*)arg;
     secp256k1_fe t;
 
     for (i = 0; i < 20000; i++) {
         t = data->fe_x;
-        secp256k1_fe_sqrt(&data->fe_x, &t);
+        j += secp256k1_fe_sqrt(&data->fe_x, &t);
         secp256k1_fe_add(&data->fe_x, &data->fe_y);
-        memory_fence(data);
     }
+    memory_fence(data);
+    CHECK(j <= 20000);
 }
 
 void bench_group_double_var(void* arg) {
@@ -214,8 +215,8 @@ void bench_group_double_var(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_gej_double_var(&data->gej_x, &data->gej_x, NULL);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_group_add_var(void* arg) {
@@ -224,8 +225,8 @@ void bench_group_add_var(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y, NULL);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_group_add_affine(void* arg) {
@@ -234,8 +235,8 @@ void bench_group_add_affine(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_gej_add_ge(&data->gej_x, &data->gej_x, &data->ge_y);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_group_add_affine_var(void* arg) {
@@ -244,40 +245,42 @@ void bench_group_add_affine_var(void* arg) {
 
     for (i = 0; i < 200000; i++) {
         secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y, NULL);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_group_jacobi_var(void* arg) {
-    int i;
+    int i, j = 0;
     bench_inv *data = (bench_inv*)arg;
 
     for (i = 0; i < 20000; i++) {
-        secp256k1_gej_has_quad_y_var(&data->gej_x);
-        memory_fence(data);
+        j += secp256k1_gej_has_quad_y_var(&data->gej_x);
     }
+    CHECK(j == 20000);
 }
 
 void bench_ecmult_wnaf(void* arg) {
-    int i;
+    int i, bits=0, overflow = 0;
     bench_inv *data = (bench_inv*)arg;
 
     for (i = 0; i < 20000; i++) {
-        secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A);
-        secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
-        memory_fence(data);
+        bits += secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A);
+        overflow += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
     }
+    CHECK(overflow >= 0);
+    CHECK(bits <= 256*20000);
 }
 
 void bench_wnaf_const(void* arg) {
-    int i;
+    int i, bits = 0, overflow = 0;
     bench_inv *data = (bench_inv*)arg;
 
     for (i = 0; i < 20000; i++) {
-        secp256k1_wnaf_const(data->wnaf, &data->scalar_x, WINDOW_A, 256);
-        secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
-        memory_fence(data);
+        bits += secp256k1_wnaf_const(data->wnaf, &data->scalar_x, WINDOW_A, 256);
+        overflow += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);
     }
+    CHECK(overflow >= 0);
+    CHECK(bits <= 256*20000);
 }
 
 
@@ -290,8 +293,8 @@ void bench_sha256(void* arg) {
         secp256k1_sha256_initialize(&sha);
         secp256k1_sha256_write(&sha, data->data, 32);
         secp256k1_sha256_finalize(&sha, data->data);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_hmac_sha256(void* arg) {
@@ -303,8 +306,8 @@ void bench_hmac_sha256(void* arg) {
         secp256k1_hmac_sha256_initialize(&hmac, data->data, 32);
         secp256k1_hmac_sha256_write(&hmac, data->data, 32);
         secp256k1_hmac_sha256_finalize(&hmac, data->data);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_rfc6979_hmac_sha256(void* arg) {
@@ -315,29 +318,35 @@ void bench_rfc6979_hmac_sha256(void* arg) {
     for (i = 0; i < 20000; i++) {
         secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 64);
         secp256k1_rfc6979_hmac_sha256_generate(&rng, data->data, 32);
-        memory_fence(data);
     }
+    memory_fence(data);
 }
 
 void bench_context_verify(void* arg) {
     int i;
+    secp256k1_context* ctx;
     (void)arg;
     for (i = 0; i < 20; i++) {
-        secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_VERIFY));
+        ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
+        memory_fence(ctx);
+        secp256k1_context_destroy(ctx);
     }
 }
 
 void bench_context_sign(void* arg) {
     int i;
+    secp256k1_context* ctx;
     (void)arg;
     for (i = 0; i < 200; i++) {
-        secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_SIGN));
+        ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
+        memory_fence(ctx);
+        secp256k1_context_destroy(ctx);
     }
 }
 
 #ifndef USE_NUM_NONE
 void bench_num_jacobi(void* arg) {
-    int i, j;
+    int i, j = 0;
     bench_inv *data = (bench_inv*)arg;
     secp256k1_num nx, norder;
 
@@ -346,9 +355,9 @@ void bench_num_jacobi(void* arg) {
     secp256k1_scalar_get_num(&norder, &data->scalar_y);
 
     for (i = 0; i < 200000; i++) {
-        j = secp256k1_num_jacobi(&nx, &norder);
-        memory_fence(&j);
+        j += secp256k1_num_jacobi(&nx, &norder);
     }
+    CHECK(j <= 200000);
 }
 #endif
 

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,6 @@ typedef struct {`
`27`	`27`	`int wnaf[256];`
`28`	`28`	`} bench_inv;`
`29`	`29`
`30`		`-`
`31`	`30`	`void bench_setup(void* arg) {`
`32`	`31`	`bench_inv data = (bench_inv)arg;`
`33`	`32`
`@@ -58,13 +57,13 @@ void bench_setup(void* arg) {`
`58`	`57`	`}`
`59`	`58`
`60`	`59`	`void bench_scalar_add(void* arg) {`
`61`		`- int i;`
	`60`	`+ int i, j = 0;`
`62`	`61`	`bench_inv data = (bench_inv)arg;`
`63`	`62`
`64`	`63`	`for (i = 0; i < 2000000; i++) {`
`65`		`- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`66`		`- memory_fence(data);`
	`64`	`+ j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`67`	`65`	`}`
	`66`	`+ CHECK(j <= 2000000);`
`68`	`67`	`}`
`69`	`68`
`70`	`69`	`void bench_scalar_negate(void* arg) {`
`@@ -73,8 +72,8 @@ void bench_scalar_negate(void* arg) {`
`73`	`72`
`74`	`73`	`for (i = 0; i < 2000000; i++) {`
`75`	`74`	`secp256k1_scalar_negate(&data->scalar_x, &data->scalar_x);`
`76`		`- memory_fence(data);`
`77`	`75`	`}`
	`76`	`+ memory_fence(data);`
`78`	`77`	`}`
`79`	`78`
`80`	`79`	`void bench_scalar_sqr(void* arg) {`
`@@ -83,8 +82,8 @@ void bench_scalar_sqr(void* arg) {`
`83`	`82`
`84`	`83`	`for (i = 0; i < 200000; i++) {`
`85`	`84`	`secp256k1_scalar_sqr(&data->scalar_x, &data->scalar_x);`
`86`		`- memory_fence(data);`
`87`	`85`	`}`
	`86`	`+ memory_fence(data);`
`88`	`87`	`}`
`89`	`88`
`90`	`89`	`void bench_scalar_mul(void* arg) {`
`@@ -93,44 +92,45 @@ void bench_scalar_mul(void* arg) {`
`93`	`92`
`94`	`93`	`for (i = 0; i < 200000; i++) {`
`95`	`94`	`secp256k1_scalar_mul(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`96`		`- memory_fence(data);`
`97`	`95`	`}`
	`96`	`+ memory_fence(data);`
`98`	`97`	`}`
`99`	`98`
`100`	`99`	`#ifdef USE_ENDOMORPHISM`
`101`	`100`	`void bench_scalar_split(void* arg) {`
`102`		`- int i;`
	`101`	`+ int i, j = 0;`
`103`	`102`	`bench_inv data = (bench_inv)arg;`
`104`	`103`
`105`	`104`	`for (i = 0; i < 20000; i++) {`
`106`		`- secp256k1_scalar l, r;`
`107`		`- secp256k1_scalar_split_lambda(&l, &r, &data->scalar_x);`
`108`		`- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`109`		`- memory_fence(data);`
	`105`	`+ secp256k1_scalar_split_lambda(&data->scalar_x, &data->scalar_y, &data->scalar_x);`
	`106`	`+ j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`110`	`107`	`}`
	`108`	`+ CHECK(j <= 2000);`
`111`	`109`	`}`
`112`	`110`	`#endif`
`113`	`111`
`114`	`112`	`void bench_scalar_inverse(void* arg) {`
`115`		`- int i;`
	`113`	`+ int i, j = 0;`
`116`	`114`	`bench_inv data = (bench_inv)arg;`
`117`	`115`
`118`	`116`	`for (i = 0; i < 2000; i++) {`
`119`	`117`	`secp256k1_scalar_inverse(&data->scalar_x, &data->scalar_x);`
`120`		`- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`121`		`- memory_fence(data);`
	`118`	`+ j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`122`	`119`	`}`
	`120`	`+ memory_fence(data);`
	`121`	`+ CHECK(j <= 2000);`
`123`	`122`	`}`
`124`	`123`
`125`	`124`	`void bench_scalar_inverse_var(void* arg) {`
`126`		`- int i;`
	`125`	`+ int i, j = 0;`
`127`	`126`	`bench_inv data = (bench_inv)arg;`
`128`	`127`
`129`	`128`	`for (i = 0; i < 2000; i++) {`
`130`	`129`	`secp256k1_scalar_inverse_var(&data->scalar_x, &data->scalar_x);`
`131`		`- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`132`		`- memory_fence(data);`
	`130`	`+ j += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`133`	`131`	`}`
	`132`	`+ memory_fence(data);`
	`133`	`+ CHECK(j <= 2000);`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`void bench_field_normalize(void* arg) {`
`@@ -139,8 +139,8 @@ void bench_field_normalize(void* arg) {`
`139`	`139`
`140`	`140`	`for (i = 0; i < 2000000; i++) {`
`141`	`141`	`secp256k1_fe_normalize(&data->fe_x);`
`142`		`- memory_fence(data);`
`143`	`142`	`}`
	`143`	`+ memory_fence(data);`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`void bench_field_normalize_weak(void* arg) {`
`@@ -149,8 +149,8 @@ void bench_field_normalize_weak(void* arg) {`
`149`	`149`
`150`	`150`	`for (i = 0; i < 2000000; i++) {`
`151`	`151`	`secp256k1_fe_normalize_weak(&data->fe_x);`
`152`		`- memory_fence(data);`
`153`	`152`	`}`
	`153`	`+ memory_fence(data);`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`void bench_field_mul(void* arg) {`
`@@ -159,8 +159,8 @@ void bench_field_mul(void* arg) {`
`159`	`159`
`160`	`160`	`for (i = 0; i < 200000; i++) {`
`161`	`161`	`secp256k1_fe_mul(&data->fe_x, &data->fe_x, &data->fe_y);`
`162`		`- memory_fence(data);`
`163`	`162`	`}`
	`163`	`+ memory_fence(data);`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`void bench_field_sqr(void* arg) {`
`@@ -169,8 +169,8 @@ void bench_field_sqr(void* arg) {`
`169`	`169`
`170`	`170`	`for (i = 0; i < 200000; i++) {`
`171`	`171`	`secp256k1_fe_sqr(&data->fe_x, &data->fe_x);`
`172`		`- memory_fence(data);`
`173`	`172`	`}`
	`173`	`+ memory_fence(data);`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`void bench_field_inverse(void* arg) {`
`@@ -180,8 +180,8 @@ void bench_field_inverse(void* arg) {`
`180`	`180`	`for (i = 0; i < 20000; i++) {`
`181`	`181`	`secp256k1_fe_inv(&data->fe_x, &data->fe_x);`
`182`	`182`	`secp256k1_fe_add(&data->fe_x, &data->fe_y);`
`183`		`- memory_fence(data);`
`184`	`183`	`}`
	`184`	`+ memory_fence(data);`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`void bench_field_inverse_var(void* arg) {`
`@@ -191,21 +191,22 @@ void bench_field_inverse_var(void* arg) {`
`191`	`191`	`for (i = 0; i < 20000; i++) {`
`192`	`192`	`secp256k1_fe_inv_var(&data->fe_x, &data->fe_x);`
`193`	`193`	`secp256k1_fe_add(&data->fe_x, &data->fe_y);`
`194`		`- memory_fence(data);`
`195`	`194`	`}`
	`195`	`+ memory_fence(data);`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`void bench_field_sqrt(void* arg) {`
`199`		`- int i;`
	`199`	`+ int i, j=0;`
`200`	`200`	`bench_inv data = (bench_inv)arg;`
`201`	`201`	`secp256k1_fe t;`
`202`	`202`
`203`	`203`	`for (i = 0; i < 20000; i++) {`
`204`	`204`	`t = data->fe_x;`
`205`		`- secp256k1_fe_sqrt(&data->fe_x, &t);`
	`205`	`+ j += secp256k1_fe_sqrt(&data->fe_x, &t);`
`206`	`206`	`secp256k1_fe_add(&data->fe_x, &data->fe_y);`
`207`		`- memory_fence(data);`
`208`	`207`	`}`
	`208`	`+ memory_fence(data);`
	`209`	`+ CHECK(j <= 20000);`
`209`	`210`	`}`
`210`	`211`
`211`	`212`	`void bench_group_double_var(void* arg) {`
`@@ -214,8 +215,8 @@ void bench_group_double_var(void* arg) {`
`214`	`215`
`215`	`216`	`for (i = 0; i < 200000; i++) {`
`216`	`217`	`secp256k1_gej_double_var(&data->gej_x, &data->gej_x, NULL);`
`217`		`- memory_fence(data);`
`218`	`218`	`}`
	`219`	`+ memory_fence(data);`
`219`	`220`	`}`
`220`	`221`
`221`	`222`	`void bench_group_add_var(void* arg) {`
`@@ -224,8 +225,8 @@ void bench_group_add_var(void* arg) {`
`224`	`225`
`225`	`226`	`for (i = 0; i < 200000; i++) {`
`226`	`227`	`secp256k1_gej_add_var(&data->gej_x, &data->gej_x, &data->gej_y, NULL);`
`227`		`- memory_fence(data);`
`228`	`228`	`}`
	`229`	`+ memory_fence(data);`
`229`	`230`	`}`
`230`	`231`
`231`	`232`	`void bench_group_add_affine(void* arg) {`
`@@ -234,8 +235,8 @@ void bench_group_add_affine(void* arg) {`
`234`	`235`
`235`	`236`	`for (i = 0; i < 200000; i++) {`
`236`	`237`	`secp256k1_gej_add_ge(&data->gej_x, &data->gej_x, &data->ge_y);`
`237`		`- memory_fence(data);`
`238`	`238`	`}`
	`239`	`+ memory_fence(data);`
`239`	`240`	`}`
`240`	`241`
`241`	`242`	`void bench_group_add_affine_var(void* arg) {`
`@@ -244,40 +245,42 @@ void bench_group_add_affine_var(void* arg) {`
`244`	`245`
`245`	`246`	`for (i = 0; i < 200000; i++) {`
`246`	`247`	`secp256k1_gej_add_ge_var(&data->gej_x, &data->gej_x, &data->ge_y, NULL);`
`247`		`- memory_fence(data);`
`248`	`248`	`}`
	`249`	`+ memory_fence(data);`
`249`	`250`	`}`
`250`	`251`
`251`	`252`	`void bench_group_jacobi_var(void* arg) {`
`252`		`- int i;`
	`253`	`+ int i, j = 0;`
`253`	`254`	`bench_inv data = (bench_inv)arg;`
`254`	`255`
`255`	`256`	`for (i = 0; i < 20000; i++) {`
`256`		`- secp256k1_gej_has_quad_y_var(&data->gej_x);`
`257`		`- memory_fence(data);`
	`257`	`+ j += secp256k1_gej_has_quad_y_var(&data->gej_x);`
`258`	`258`	`}`
	`259`	`+ CHECK(j == 20000);`
`259`	`260`	`}`
`260`	`261`
`261`	`262`	`void bench_ecmult_wnaf(void* arg) {`
`262`		`- int i;`
	`263`	`+ int i, bits=0, overflow = 0;`
`263`	`264`	`bench_inv data = (bench_inv)arg;`
`264`	`265`
`265`	`266`	`for (i = 0; i < 20000; i++) {`
`266`		`- secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A);`
`267`		`- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`268`		`- memory_fence(data);`
	`267`	`+ bits += secp256k1_ecmult_wnaf(data->wnaf, 256, &data->scalar_x, WINDOW_A);`
	`268`	`+ overflow += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`269`	`269`	`}`
	`270`	`+ CHECK(overflow >= 0);`
	`271`	`+ CHECK(bits <= 256*20000);`
`270`	`272`	`}`
`271`	`273`
`272`	`274`	`void bench_wnaf_const(void* arg) {`
`273`		`- int i;`
	`275`	`+ int i, bits = 0, overflow = 0;`
`274`	`276`	`bench_inv data = (bench_inv)arg;`
`275`	`277`
`276`	`278`	`for (i = 0; i < 20000; i++) {`
`277`		`- secp256k1_wnaf_const(data->wnaf, &data->scalar_x, WINDOW_A, 256);`
`278`		`- secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`279`		`- memory_fence(data);`
	`279`	`+ bits += secp256k1_wnaf_const(data->wnaf, &data->scalar_x, WINDOW_A, 256);`
	`280`	`+ overflow += secp256k1_scalar_add(&data->scalar_x, &data->scalar_x, &data->scalar_y);`
`280`	`281`	`}`
	`282`	`+ CHECK(overflow >= 0);`
	`283`	`+ CHECK(bits <= 256*20000);`
`281`	`284`	`}`
`282`	`285`
`283`	`286`
`@@ -290,8 +293,8 @@ void bench_sha256(void* arg) {`
`290`	`293`	`secp256k1_sha256_initialize(&sha);`
`291`	`294`	`secp256k1_sha256_write(&sha, data->data, 32);`
`292`	`295`	`secp256k1_sha256_finalize(&sha, data->data);`
`293`		`- memory_fence(data);`
`294`	`296`	`}`
	`297`	`+ memory_fence(data);`
`295`	`298`	`}`
`296`	`299`
`297`	`300`	`void bench_hmac_sha256(void* arg) {`
`@@ -303,8 +306,8 @@ void bench_hmac_sha256(void* arg) {`
`303`	`306`	`secp256k1_hmac_sha256_initialize(&hmac, data->data, 32);`
`304`	`307`	`secp256k1_hmac_sha256_write(&hmac, data->data, 32);`
`305`	`308`	`secp256k1_hmac_sha256_finalize(&hmac, data->data);`
`306`		`- memory_fence(data);`
`307`	`309`	`}`
	`310`	`+ memory_fence(data);`
`308`	`311`	`}`
`309`	`312`
`310`	`313`	`void bench_rfc6979_hmac_sha256(void* arg) {`
`@@ -315,29 +318,35 @@ void bench_rfc6979_hmac_sha256(void* arg) {`
`315`	`318`	`for (i = 0; i < 20000; i++) {`
`316`	`319`	`secp256k1_rfc6979_hmac_sha256_initialize(&rng, data->data, 64);`
`317`	`320`	`secp256k1_rfc6979_hmac_sha256_generate(&rng, data->data, 32);`
`318`		`- memory_fence(data);`
`319`	`321`	`}`
	`322`	`+ memory_fence(data);`
`320`	`323`	`}`
`321`	`324`
`322`	`325`	`void bench_context_verify(void* arg) {`
`323`	`326`	`int i;`
	`327`	`+ secp256k1_context* ctx;`
`324`	`328`	`(void)arg;`
`325`	`329`	`for (i = 0; i < 20; i++) {`
`326`		`- secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_VERIFY));`
	`330`	`+ ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);`
	`331`	`+ memory_fence(ctx);`
	`332`	`+ secp256k1_context_destroy(ctx);`
`327`	`333`	`}`
`328`	`334`	`}`
`329`	`335`
`330`	`336`	`void bench_context_sign(void* arg) {`
`331`	`337`	`int i;`
	`338`	`+ secp256k1_context* ctx;`
`332`	`339`	`(void)arg;`
`333`	`340`	`for (i = 0; i < 200; i++) {`
`334`		`- secp256k1_context_destroy(secp256k1_context_create(SECP256K1_CONTEXT_SIGN));`
	`341`	`+ ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);`
	`342`	`+ memory_fence(ctx);`
	`343`	`+ secp256k1_context_destroy(ctx);`
`335`	`344`	`}`
`336`	`345`	`}`
`337`	`346`
`338`	`347`	`#ifndef USE_NUM_NONE`
`339`	`348`	`void bench_num_jacobi(void* arg) {`
`340`		`- int i, j;`
	`349`	`+ int i, j = 0;`
`341`	`350`	`bench_inv data = (bench_inv)arg;`
`342`	`351`	`secp256k1_num nx, norder;`
`343`	`352`
`@@ -346,9 +355,9 @@ void bench_num_jacobi(void* arg) {`
`346`	`355`	`secp256k1_scalar_get_num(&norder, &data->scalar_y);`
`347`	`356`
`348`	`357`	`for (i = 0; i < 200000; i++) {`
`349`		`- j = secp256k1_num_jacobi(&nx, &norder);`
`350`		`- memory_fence(&j);`
	`358`	`+ j += secp256k1_num_jacobi(&nx, &norder);`
`351`	`359`	`}`
	`360`	`+ CHECK(j <= 200000);`
`352`	`361`	`}`
`353`	`362`	`#endif`
`354`	`363`