Skip to content

Commit bc65aa7

Browse files
sipajonasnick
sipa
authored and
jonasnick
committed
Add bench_ecmult
1 parent dba5471 commit bc65aa7

File tree

2 files changed

+186
-1
lines changed

2 files changed

+186
-1
lines changed

‎Makefile.am

+5-1
Original file line numberDiff line numberDiff line change
@@ -81,14 +81,17 @@ libsecp256k1_jni_la_CPPFLAGS = -DSECP256K1_BUILD $(JNI_INCLUDES)
8181

8282
noinst_PROGRAMS =
8383
if USE_BENCHMARK
84-
noinst_PROGRAMS += bench_verify bench_sign bench_internal
84+
noinst_PROGRAMS += bench_verify bench_sign bench_internal bench_ecmult
8585
bench_verify_SOURCES = src/bench_verify.c
8686
bench_verify_LDADD = libsecp256k1.la $(SECP_LIBS) $(SECP_TEST_LIBS) $(COMMON_LIB)
8787
bench_sign_SOURCES = src/bench_sign.c
8888
bench_sign_LDADD = libsecp256k1.la $(SECP_LIBS) $(SECP_TEST_LIBS) $(COMMON_LIB)
8989
bench_internal_SOURCES = src/bench_internal.c
9090
bench_internal_LDADD = $(SECP_LIBS) $(COMMON_LIB)
9191
bench_internal_CPPFLAGS = -DSECP256K1_BUILD $(SECP_INCLUDES)
92+
bench_ecmult_SOURCES = src/bench_ecmult.c
93+
bench_ecmult_LDADD = $(SECP_LIBS) $(COMMON_LIB)
94+
bench_ecmult_CPPFLAGS = -DSECP256K1_BUILD $(SECP_INCLUDES)
9295
endif
9396

9497
TESTS =
@@ -161,6 +164,7 @@ $(gen_context_BIN): $(gen_context_OBJECTS)
161164
$(libsecp256k1_la_OBJECTS): src/ecmult_static_context.h
162165
$(tests_OBJECTS): src/ecmult_static_context.h
163166
$(bench_internal_OBJECTS): src/ecmult_static_context.h
167+
$(bench_ecmult_OBJECTS): src/ecmult_static_context.h
164168

165169
src/ecmult_static_context.h: $(gen_context_BIN)
166170
./$(gen_context_BIN)

‎src/bench_ecmult.c

+181
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,181 @@
1+
/**********************************************************************
2+
* Copyright (c) 2017 Pieter Wuille *
3+
* Distributed under the MIT software license, see the accompanying *
4+
* file COPYING or http://www.opensource.org/licenses/mit-license.php.*
5+
**********************************************************************/
6+
#include <stdio.h>
7+
8+
#include "include/secp256k1.h"
9+
10+
#include "util.h"
11+
#include "hash_impl.h"
12+
#include "num_impl.h"
13+
#include "field_impl.h"
14+
#include "group_impl.h"
15+
#include "scalar_impl.h"
16+
#include "ecmult_impl.h"
17+
#include "bench.h"
18+
#include "secp256k1.c"
19+
20+
#define POINTS 32768
21+
#define ITERS 10000
22+
23+
typedef struct {
24+
/* Setup once in advance */
25+
secp256k1_context* ctx;
26+
secp256k1_scratch_space* scratch;
27+
secp256k1_scalar* scalars;
28+
secp256k1_ge* pubkeys;
29+
secp256k1_scalar* seckeys;
30+
secp256k1_gej* expected_output;
31+
32+
/* Changes per test */
33+
size_t count;
34+
int includes_g;
35+
36+
/* Changes per test iteration */
37+
size_t offset1;
38+
size_t offset2;
39+
40+
/* Test output. */
41+
secp256k1_gej* output;
42+
} bench_data;
43+
44+
static int bench_callback(secp256k1_scalar* sc, secp256k1_ge* ge, size_t idx, void* arg) {
45+
bench_data* data = (bench_data*)arg;
46+
if (data->includes_g) ++idx;
47+
if (idx == 0) {
48+
*sc = data->scalars[data->offset1];
49+
*ge = secp256k1_ge_const_g;
50+
} else {
51+
*sc = data->scalars[(data->offset1 + idx) % POINTS];
52+
*ge = data->pubkeys[(data->offset2 + idx - 1) % POINTS];
53+
}
54+
return 1;
55+
}
56+
57+
static void bench_ecmult(void* arg) {
58+
bench_data* data = (bench_data*)arg;
59+
60+
size_t count = data->count;
61+
int includes_g = data->includes_g;
62+
size_t iters = 1 + ITERS / count;
63+
size_t iter;
64+
65+
for (iter = 0; iter < iters; ++iter) {
66+
secp256k1_ecmult_multi(&data->ctx->ecmult_ctx, data->scratch, &data->output[iter], data->includes_g ? &data->scalars[data->offset1] : NULL, bench_callback, arg, count - includes_g);
67+
data->offset1 = (data->offset1 + count) % POINTS;
68+
data->offset2 = (data->offset2 + count - 1) % POINTS;
69+
}
70+
}
71+
72+
static void bench_ecmult_setup(void* arg) {
73+
bench_data* data = (bench_data*)arg;
74+
data->offset1 = (data->count * 0x537b7f6f + 0x8f66a481) % POINTS;
75+
data->offset2 = (data->count * 0x7f6f537b + 0x6a1a8f49) % POINTS;
76+
}
77+
78+
static void bench_ecmult_teardown(void* arg) {
79+
bench_data* data = (bench_data*)arg;
80+
size_t iters = 1 + ITERS / data->count;
81+
size_t iter;
82+
/* Verify the results in teardown, to avoid doing comparisons while benchmarking. */
83+
for (iter = 0; iter < iters; ++iter) {
84+
secp256k1_gej tmp;
85+
secp256k1_gej_add_var(&tmp, &data->output[iter], &data->expected_output[iter], NULL);
86+
CHECK(secp256k1_gej_is_infinity(&tmp));
87+
}
88+
}
89+
90+
static void generate_scalar(uint32_t num, secp256k1_scalar* scalar) {
91+
secp256k1_sha256 sha256;
92+
unsigned char c[11] = {'e', 'c', 'm', 'u', 'l', 't', 0, 0, 0, 0};
93+
unsigned char buf[32];
94+
int overflow = 0;
95+
c[6] = num;
96+
c[7] = num >> 8;
97+
c[8] = num >> 16;
98+
c[9] = num >> 24;
99+
secp256k1_sha256_initialize(&sha256);
100+
secp256k1_sha256_write(&sha256, c, sizeof(c));
101+
secp256k1_sha256_finalize(&sha256, buf);
102+
secp256k1_scalar_set_b32(scalar, buf, &overflow);
103+
CHECK(!overflow);
104+
}
105+
106+
static void run_test(bench_data* data, size_t count, int includes_g) {
107+
char str[32];
108+
static const secp256k1_scalar zero = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
109+
size_t iters = 1 + ITERS / count;
110+
size_t iter;
111+
112+
data->count = count;
113+
data->includes_g = includes_g;
114+
115+
/* Compute (the negation of) the expected results directly. */
116+
data->offset1 = (data->count * 0x537b7f6f + 0x8f66a481) % POINTS;
117+
data->offset2 = (data->count * 0x7f6f537b + 0x6a1a8f49) % POINTS;
118+
for (iter = 0; iter < iters; ++iter) {
119+
secp256k1_scalar tmp;
120+
secp256k1_scalar total = data->scalars[(data->offset1++) % POINTS];
121+
size_t i = 0;
122+
for (i = 0; i + 1 < count; ++i) {
123+
secp256k1_scalar_mul(&tmp, &data->seckeys[(data->offset2++) % POINTS], &data->scalars[(data->offset1++) % POINTS]);
124+
secp256k1_scalar_add(&total, &total, &tmp);
125+
}
126+
secp256k1_scalar_negate(&total, &total);
127+
secp256k1_ecmult(&data->ctx->ecmult_ctx, &data->expected_output[iter], NULL, &zero, &total);
128+
}
129+
130+
/* Run the benchmark. */
131+
sprintf(str, includes_g ? "ecmult_%ig" : "ecmult_%i", (int)count);
132+
run_benchmark(str, bench_ecmult, bench_ecmult_setup, bench_ecmult_teardown, data, 10, count * (1 + ITERS / count));
133+
}
134+
135+
int main(int argc, char **argv) {
136+
bench_data data;
137+
int i, p;
138+
secp256k1_gej* pubkeys_gej;
139+
140+
/* Allocate stuff */
141+
data.ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
142+
data.scratch = secp256k1_scratch_space_create(data.ctx, POINTS * 1024, POINTS * 5 * 1024);
143+
data.scalars = malloc(sizeof(secp256k1_scalar) * POINTS);
144+
data.seckeys = malloc(sizeof(secp256k1_scalar) * POINTS);
145+
data.pubkeys = malloc(sizeof(secp256k1_ge) * POINTS);
146+
data.expected_output = malloc(sizeof(secp256k1_gej) * (ITERS + 1));
147+
data.output = malloc(sizeof(secp256k1_gej) * (ITERS + 1));
148+
149+
/* Generate a set of scalars, and private/public keypairs. */
150+
pubkeys_gej = malloc(sizeof(secp256k1_gej) * POINTS);
151+
secp256k1_gej_set_ge(&pubkeys_gej[0], &secp256k1_ge_const_g);
152+
secp256k1_scalar_set_int(&data.seckeys[0], 1);
153+
for (i = 0; i < POINTS; ++i) {
154+
generate_scalar(i, &data.scalars[i]);
155+
if (i) {
156+
secp256k1_gej_double_var(&pubkeys_gej[i], &pubkeys_gej[i - 1], NULL);
157+
secp256k1_scalar_add(&data.seckeys[i], &data.seckeys[i - 1], &data.seckeys[i - 1]);
158+
}
159+
}
160+
secp256k1_ge_set_all_gej_var(data.pubkeys, pubkeys_gej, POINTS, &data.ctx->error_callback);
161+
free(pubkeys_gej);
162+
163+
for (i = 1; i <= 8; ++i) {
164+
run_test(&data, i, 1);
165+
}
166+
167+
for (p = 0; p <= 11; ++p) {
168+
for (i = 9; i <= 16; ++i) {
169+
run_test(&data, i << p, 1);
170+
}
171+
}
172+
secp256k1_context_destroy(data.ctx);
173+
secp256k1_scratch_space_destroy(data.scratch);
174+
free(data.scalars);
175+
free(data.pubkeys);
176+
free(data.seckeys);
177+
free(data.output);
178+
free(data.expected_output);
179+
180+
return(0);
181+
}

0 commit comments

Comments
 (0)