Bitcoin Core  22.99.0
P2P Digital Currency
bench_ecmult.c
Go to the documentation of this file.
1 /***********************************************************************
2  * Copyright (c) 2017 Pieter Wuille *
3  * Distributed under the MIT software license, see the accompanying *
4  * file COPYING or https://www.opensource.org/licenses/mit-license.php.*
5  ***********************************************************************/
6 #include <stdio.h>
7 
8 #include "secp256k1.c"
9 #include "../include/secp256k1.h"
10 
11 #include "util.h"
12 #include "hash_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 
19 #define POINTS 32768
20 
21 void help(char **argv) {
22  printf("Benchmark EC multiplication algorithms\n");
23  printf("\n");
24  printf("Usage: %s <help|pippenger_wnaf|strauss_wnaf|simple>\n", argv[0]);
25  printf("The output shows the number of multiplied and summed points right after the\n");
26  printf("function name. The letter 'g' indicates that one of the points is the generator.\n");
27  printf("The benchmarks are divided by the number of points.\n");
28  printf("\n");
29  printf("default (ecmult_multi): picks pippenger_wnaf or strauss_wnaf depending on the\n");
30  printf(" batch size\n");
31  printf("pippenger_wnaf: for all batch sizes\n");
32  printf("strauss_wnaf: for all batch sizes\n");
33  printf("simple: multiply and sum each point individually\n");
34 }
35 
36 typedef struct {
37  /* Setup once in advance */
46 
47  /* Changes per benchmark */
48  size_t count;
50 
51  /* Changes per benchmark iteration, used to pick different scalars and pubkeys
52  * in each run. */
53  size_t offset1;
54  size_t offset2;
55 
56  /* Benchmark output. */
58 } bench_data;
59 
60 /* Hashes x into [0, POINTS) twice and store the result in offset1 and offset2. */
61 static void hash_into_offset(bench_data* data, size_t x) {
62  data->offset1 = (x * 0x537b7f6f + 0x8f66a481) % POINTS;
63  data->offset2 = (x * 0x7f6f537b + 0x6a1a8f49) % POINTS;
64 }
65 
66 /* Check correctness of the benchmark by computing
67  * sum(outputs) ?= (sum(scalars_gen) + sum(seckeys)*sum(scalars))*G */
68 static void bench_ecmult_teardown_helper(bench_data* data, size_t* seckey_offset, size_t* scalar_offset, size_t* scalar_gen_offset, int iters) {
69  int i;
70  secp256k1_gej sum_output, tmp;
71  secp256k1_scalar sum_scalars;
72 
73  secp256k1_gej_set_infinity(&sum_output);
74  secp256k1_scalar_clear(&sum_scalars);
75  for (i = 0; i < iters; ++i) {
76  secp256k1_gej_add_var(&sum_output, &sum_output, &data->output[i], NULL);
77  if (scalar_gen_offset != NULL) {
78  secp256k1_scalar_add(&sum_scalars, &sum_scalars, &data->scalars[(*scalar_gen_offset+i) % POINTS]);
79  }
80  if (seckey_offset != NULL) {
81  secp256k1_scalar s = data->seckeys[(*seckey_offset+i) % POINTS];
82  secp256k1_scalar_mul(&s, &s, &data->scalars[(*scalar_offset+i) % POINTS]);
83  secp256k1_scalar_add(&sum_scalars, &sum_scalars, &s);
84  }
85  }
86  secp256k1_ecmult_gen(&data->ctx->ecmult_gen_ctx, &tmp, &sum_scalars);
87  secp256k1_gej_neg(&tmp, &tmp);
88  secp256k1_gej_add_var(&tmp, &tmp, &sum_output, NULL);
90 }
91 
92 static void bench_ecmult_setup(void* arg) {
93  bench_data* data = (bench_data*)arg;
94  /* Re-randomize offset to ensure that we're using different scalars and
95  * group elements in each run. */
96  hash_into_offset(data, data->offset1);
97 }
98 
99 static void bench_ecmult_gen(void* arg, int iters) {
100  bench_data* data = (bench_data*)arg;
101  int i;
102 
103  for (i = 0; i < iters; ++i) {
104  secp256k1_ecmult_gen(&data->ctx->ecmult_gen_ctx, &data->output[i], &data->scalars[(data->offset1+i) % POINTS]);
105  }
106 }
107 
108 static void bench_ecmult_gen_teardown(void* arg, int iters) {
109  bench_data* data = (bench_data*)arg;
110  bench_ecmult_teardown_helper(data, NULL, NULL, &data->offset1, iters);
111 }
112 
113 static void bench_ecmult_const(void* arg, int iters) {
114  bench_data* data = (bench_data*)arg;
115  int i;
116 
117  for (i = 0; i < iters; ++i) {
118  secp256k1_ecmult_const(&data->output[i], &data->pubkeys[(data->offset1+i) % POINTS], &data->scalars[(data->offset2+i) % POINTS], 256);
119  }
120 }
121 
122 static void bench_ecmult_const_teardown(void* arg, int iters) {
123  bench_data* data = (bench_data*)arg;
124  bench_ecmult_teardown_helper(data, &data->offset1, &data->offset2, NULL, iters);
125 }
126 
127 static void bench_ecmult_1(void* arg, int iters) {
128  bench_data* data = (bench_data*)arg;
129  int i;
130 
131  for (i = 0; i < iters; ++i) {
132  secp256k1_ecmult(&data->ctx->ecmult_ctx, &data->output[i], &data->pubkeys_gej[(data->offset1+i) % POINTS], &data->scalars[(data->offset2+i) % POINTS], NULL);
133  }
134 }
135 
136 static void bench_ecmult_1_teardown(void* arg, int iters) {
137  bench_data* data = (bench_data*)arg;
138  bench_ecmult_teardown_helper(data, &data->offset1, &data->offset2, NULL, iters);
139 }
140 
141 static void bench_ecmult_1g(void* arg, int iters) {
142  bench_data* data = (bench_data*)arg;
143  secp256k1_scalar zero;
144  int i;
145 
146  secp256k1_scalar_set_int(&zero, 0);
147  for (i = 0; i < iters; ++i) {
148  secp256k1_ecmult(&data->ctx->ecmult_ctx, &data->output[i], NULL, &zero, &data->scalars[(data->offset1+i) % POINTS]);
149  }
150 }
151 
152 static void bench_ecmult_1g_teardown(void* arg, int iters) {
153  bench_data* data = (bench_data*)arg;
154  bench_ecmult_teardown_helper(data, NULL, NULL, &data->offset1, iters);
155 }
156 
157 static void bench_ecmult_2g(void* arg, int iters) {
158  bench_data* data = (bench_data*)arg;
159  int i;
160 
161  for (i = 0; i < iters/2; ++i) {
162  secp256k1_ecmult(&data->ctx->ecmult_ctx, &data->output[i], &data->pubkeys_gej[(data->offset1+i) % POINTS], &data->scalars[(data->offset2+i) % POINTS], &data->scalars[(data->offset1+i) % POINTS]);
163  }
164 }
165 
166 static void bench_ecmult_2g_teardown(void* arg, int iters) {
167  bench_data* data = (bench_data*)arg;
168  bench_ecmult_teardown_helper(data, &data->offset1, &data->offset2, &data->offset1, iters/2);
169 }
170 
171 static void run_ecmult_bench(bench_data* data, int iters) {
172  char str[32];
173  sprintf(str, "ecmult_gen");
175  sprintf(str, "ecmult_const");
177  /* ecmult with non generator point */
178  sprintf(str, "ecmult 1");
180  /* ecmult with generator point */
181  sprintf(str, "ecmult 1g");
183  /* ecmult with generator and non-generator point. The reported time is per point. */
184  sprintf(str, "ecmult 2g");
186 }
187 
188 static int bench_ecmult_multi_callback(secp256k1_scalar* sc, secp256k1_ge* ge, size_t idx, void* arg) {
189  bench_data* data = (bench_data*)arg;
190  if (data->includes_g) ++idx;
191  if (idx == 0) {
192  *sc = data->scalars[data->offset1];
193  *ge = secp256k1_ge_const_g;
194  } else {
195  *sc = data->scalars[(data->offset1 + idx) % POINTS];
196  *ge = data->pubkeys[(data->offset2 + idx - 1) % POINTS];
197  }
198  return 1;
199 }
200 
201 static void bench_ecmult_multi(void* arg, int iters) {
202  bench_data* data = (bench_data*)arg;
203 
204  int includes_g = data->includes_g;
205  int iter;
206  int count = data->count;
207  iters = iters / data->count;
208 
209  for (iter = 0; iter < iters; ++iter) {
210  data->ecmult_multi(&data->ctx->error_callback, &data->ctx->ecmult_ctx, data->scratch, &data->output[iter], data->includes_g ? &data->scalars[data->offset1] : NULL, bench_ecmult_multi_callback, arg, count - includes_g);
211  data->offset1 = (data->offset1 + count) % POINTS;
212  data->offset2 = (data->offset2 + count - 1) % POINTS;
213  }
214 }
215 
216 static void bench_ecmult_multi_setup(void* arg) {
217  bench_data* data = (bench_data*)arg;
218  hash_into_offset(data, data->count);
219 }
220 
221 static void bench_ecmult_multi_teardown(void* arg, int iters) {
222  bench_data* data = (bench_data*)arg;
223  int iter;
224  iters = iters / data->count;
225  /* Verify the results in teardown, to avoid doing comparisons while benchmarking. */
226  for (iter = 0; iter < iters; ++iter) {
227  secp256k1_gej tmp;
228  secp256k1_gej_add_var(&tmp, &data->output[iter], &data->expected_output[iter], NULL);
230  }
231 }
232 
233 static void generate_scalar(uint32_t num, secp256k1_scalar* scalar) {
235  unsigned char c[10] = {'e', 'c', 'm', 'u', 'l', 't', 0, 0, 0, 0};
236  unsigned char buf[32];
237  int overflow = 0;
238  c[6] = num;
239  c[7] = num >> 8;
240  c[8] = num >> 16;
241  c[9] = num >> 24;
243  secp256k1_sha256_write(&sha256, c, sizeof(c));
245  secp256k1_scalar_set_b32(scalar, buf, &overflow);
246  CHECK(!overflow);
247 }
248 
249 static void run_ecmult_multi_bench(bench_data* data, size_t count, int includes_g, int num_iters) {
250  char str[32];
251  static const secp256k1_scalar zero = SECP256K1_SCALAR_CONST(0, 0, 0, 0, 0, 0, 0, 0);
252  size_t iters = 1 + num_iters / count;
253  size_t iter;
254 
255  data->count = count;
256  data->includes_g = includes_g;
257 
258  /* Compute (the negation of) the expected results directly. */
259  hash_into_offset(data, data->count);
260  for (iter = 0; iter < iters; ++iter) {
261  secp256k1_scalar tmp;
262  secp256k1_scalar total = data->scalars[(data->offset1++) % POINTS];
263  size_t i = 0;
264  for (i = 0; i + 1 < count; ++i) {
265  secp256k1_scalar_mul(&tmp, &data->seckeys[(data->offset2++) % POINTS], &data->scalars[(data->offset1++) % POINTS]);
266  secp256k1_scalar_add(&total, &total, &tmp);
267  }
268  secp256k1_scalar_negate(&total, &total);
269  secp256k1_ecmult(&data->ctx->ecmult_ctx, &data->expected_output[iter], NULL, &zero, &total);
270  }
271 
272  /* Run the benchmark. */
273  sprintf(str, includes_g ? "ecmult_multi %ig" : "ecmult_multi %i", (int)count);
275 }
276 
277 int main(int argc, char **argv) {
278  bench_data data;
279  int i, p;
280  size_t scratch_size;
281 
282  int iters = get_iters(10000);
283 
285 
286  if (argc > 1) {
287  if(have_flag(argc, argv, "-h")
288  || have_flag(argc, argv, "--help")
289  || have_flag(argc, argv, "help")) {
290  help(argv);
291  return 1;
292  } else if(have_flag(argc, argv, "pippenger_wnaf")) {
293  printf("Using pippenger_wnaf:\n");
295  } else if(have_flag(argc, argv, "strauss_wnaf")) {
296  printf("Using strauss_wnaf:\n");
298  } else if(have_flag(argc, argv, "simple")) {
299  printf("Using simple algorithm:\n");
300  } else {
301  fprintf(stderr, "%s: unrecognized argument '%s'.\n\n", argv[0], argv[1]);
302  help(argv);
303  return 1;
304  }
305  }
306 
309  if (!have_flag(argc, argv, "simple")) {
310  data.scratch = secp256k1_scratch_space_create(data.ctx, scratch_size);
311  } else {
312  data.scratch = NULL;
313  }
314 
315  /* Allocate stuff */
316  data.scalars = malloc(sizeof(secp256k1_scalar) * POINTS);
317  data.seckeys = malloc(sizeof(secp256k1_scalar) * POINTS);
318  data.pubkeys = malloc(sizeof(secp256k1_ge) * POINTS);
319  data.pubkeys_gej = malloc(sizeof(secp256k1_gej) * POINTS);
320  data.expected_output = malloc(sizeof(secp256k1_gej) * (iters + 1));
321  data.output = malloc(sizeof(secp256k1_gej) * (iters + 1));
322 
323  /* Generate a set of scalars, and private/public keypairs. */
325  secp256k1_scalar_set_int(&data.seckeys[0], 1);
326  for (i = 0; i < POINTS; ++i) {
327  generate_scalar(i, &data.scalars[i]);
328  if (i) {
329  secp256k1_gej_double_var(&data.pubkeys_gej[i], &data.pubkeys_gej[i - 1], NULL);
330  secp256k1_scalar_add(&data.seckeys[i], &data.seckeys[i - 1], &data.seckeys[i - 1]);
331  }
332  }
334 
335 
336  /* Initialize offset1 and offset2 */
337  hash_into_offset(&data, 0);
338  run_ecmult_bench(&data, iters);
339 
340  for (i = 1; i <= 8; ++i) {
341  run_ecmult_multi_bench(&data, i, 1, iters);
342  }
343 
344  /* This is disabled with low count of iterations because the loop runs 77 times even with iters=1
345  * and the higher it goes the longer the computation takes(more points)
346  * So we don't run this benchmark with low iterations to prevent slow down */
347  if (iters > 2) {
348  for (p = 0; p <= 11; ++p) {
349  for (i = 9; i <= 16; ++i) {
350  run_ecmult_multi_bench(&data, i << p, 1, iters);
351  }
352  }
353  }
354 
355  if (data.scratch != NULL) {
357  }
359  free(data.scalars);
360  free(data.pubkeys);
361  free(data.pubkeys_gej);
362  free(data.seckeys);
363  free(data.output);
364  free(data.expected_output);
365 
366  return(0);
367 }
secp256k1_gej_set_infinity
static void secp256k1_gej_set_infinity(secp256k1_gej *r)
Set a group element (jacobian) equal to the point at infinity.
secp256k1_scalar_negate
static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a)
Compute the complement of a scalar (modulo the group order).
bench_data::pubkeys_gej
secp256k1_gej * pubkeys_gej
Definition: bench_ecmult.c:42
count
static int count
Definition: tests.c:41
SECP256K1_CONTEXT_VERIFY
#define SECP256K1_CONTEXT_VERIFY
Flags to pass to secp256k1_context_create, secp256k1_context_preallocated_size, and secp256k1_context...
Definition: secp256k1.h:184
bench_ecmult_multi_teardown
static void bench_ecmult_multi_teardown(void *arg, int iters)
Definition: bench_ecmult.c:221
secp256k1_scratch_space_create
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT secp256k1_scratch_space * secp256k1_scratch_space_create(const secp256k1_context *ctx, size_t size) SECP256K1_ARG_NONNULL(1)
Create a secp256k1 scratch space object.
Definition: secp256k1.c:227
bench_data::offset2
size_t offset2
Definition: bench_ecmult.c:54
bench_ecmult_2g_teardown
static void bench_ecmult_2g_teardown(void *arg, int iters)
Definition: bench_ecmult.c:166
field_impl.h
SECP256K1_CONTEXT_SIGN
#define SECP256K1_CONTEXT_SIGN
Definition: secp256k1.h:185
bench_data::expected_output
secp256k1_gej * expected_output
Definition: bench_ecmult.c:44
help
void help(char **argv)
Definition: bench_ecmult.c:21
bench_ecmult_1
static void bench_ecmult_1(void *arg, int iters)
Definition: bench_ecmult.c:127
secp256k1_context_struct
Definition: secp256k1.c:75
bench_data::output
secp256k1_gej * output
Definition: bench_ecmult.c:57
POINTS
#define POINTS
Definition: bench_ecmult.c:19
bench_ecmult_multi_callback
static int bench_ecmult_multi_callback(secp256k1_scalar *sc, secp256k1_ge *ge, size_t idx, void *arg)
Definition: bench_ecmult.c:188
group_impl.h
bench_ecmult_gen_teardown
static void bench_ecmult_gen_teardown(void *arg, int iters)
Definition: bench_ecmult.c:108
tinyformat::printf
void printf(const char *fmt, const Args &... args)
Format list of arguments to std::cout, according to the given format string.
Definition: tinyformat.h:1079
sha256
Internal SHA-256 implementation.
Definition: sha256.cpp:46
ecmult_impl.h
bench_ecmult_setup
static void bench_ecmult_setup(void *arg)
Definition: bench_ecmult.c:92
SECP256K1_SCALAR_CONST
#define SECP256K1_SCALAR_CONST(d7, d6, d5, d4, d3, d2, d1, d0)
Definition: scalar_4x64.h:17
secp256k1_scratch_space_struct
Definition: scratch.h:12
util.h
bench.h
secp256k1_sha256
Definition: hash.h:13
secp256k1_context_destroy
SECP256K1_API void secp256k1_context_destroy(secp256k1_context *ctx)
Destroy a secp256k1 context object (created in dynamically allocated memory).
Definition: secp256k1.c:202
secp256k1_scratch_space_destroy
SECP256K1_API void secp256k1_scratch_space_destroy(const secp256k1_context *ctx, secp256k1_scratch_space *scratch) SECP256K1_ARG_NONNULL(1)
Destroy a secp256k1 scratch space.
Definition: secp256k1.c:232
bench_ecmult_2g
static void bench_ecmult_2g(void *arg, int iters)
Definition: bench_ecmult.c:157
secp256k1_context_create
SECP256K1_API secp256k1_context * secp256k1_context_create(unsigned int flags) SECP256K1_WARN_UNUSED_RESULT
Create a secp256k1 context object (in dynamically allocated memory).
Definition: secp256k1.c:158
secp256k1_scalar_add
static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b)
Add two scalars together (modulo the group order).
secp256k1_ecmult_strauss_batch_single
static int secp256k1_ecmult_strauss_batch_single(const secp256k1_callback *error_callback, const secp256k1_ecmult_context *actx, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n)
Definition: ecmult_impl.h:621
secp256k1_scalar
A scalar modulo the group order of the secp256k1 curve.
Definition: scalar_4x64.h:13
STRAUSS_SCRATCH_OBJECTS
#define STRAUSS_SCRATCH_OBJECTS
Definition: ecmult_impl.h:71
secp256k1_ecmult
static void secp256k1_ecmult(const secp256k1_ecmult_context *ctx, secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_scalar *na, const secp256k1_scalar *ng)
Double multiply: R = na*A + ng*G.
secp256k1_ecmult_gen
static void secp256k1_ecmult_gen(const secp256k1_ecmult_gen_context *ctx, secp256k1_gej *r, const secp256k1_scalar *a)
Multiply with the generator: R = a*G.
secp256k1_ge_const_g
static const secp256k1_ge secp256k1_ge_const_g
Generator for secp256k1, value 'g' defined in "Standards for Efficient Cryptography" (SEC2) 2....
Definition: group_impl.h:52
secp256k1_gej
A group element of the secp256k1 curve, in jacobian coordinates.
Definition: group.h:23
bench_ecmult_multi_setup
static void bench_ecmult_multi_setup(void *arg)
Definition: bench_ecmult.c:216
run_benchmark
void run_benchmark(char *name, void(*benchmark)(void *, int), void(*setup)(void *), void(*teardown)(void *, int), void *data, int count, int iter)
Definition: bench.h:76
bench_data::count
size_t count
Definition: bench_ecmult.c:48
hash_into_offset
static void hash_into_offset(bench_data *data, size_t x)
Definition: bench_ecmult.c:61
bench_data::ecmult_multi
secp256k1_ecmult_multi_func ecmult_multi
Definition: bench_ecmult.c:45
secp256k1_sha256_write
static void secp256k1_sha256_write(secp256k1_sha256 *hash, const unsigned char *data, size_t size)
bench_data::offset1
size_t offset1
Definition: bench_ecmult.c:53
secp256k1.c
bench_data::scalars
secp256k1_scalar * scalars
Definition: bench_ecmult.c:40
secp256k1_context_struct::ecmult_gen_ctx
secp256k1_ecmult_gen_context ecmult_gen_ctx
Definition: secp256k1.c:77
secp256k1_sha256_finalize
static void secp256k1_sha256_finalize(secp256k1_sha256 *hash, unsigned char *out32)
secp256k1_context_struct::ecmult_ctx
secp256k1_ecmult_context ecmult_ctx
Definition: secp256k1.c:76
secp256k1_gej_neg
static void secp256k1_gej_neg(secp256k1_gej *r, const secp256k1_gej *a)
Set r equal to the inverse of a (i.e., mirrored around the X axis)
secp256k1_ecmult_const
static void secp256k1_ecmult_const(secp256k1_gej *r, const secp256k1_ge *a, const secp256k1_scalar *q, int bits)
Multiply: R = q*A (in constant-time) Here bits should be set to the maximum bitlength of the absolute...
hash_impl.h
secp256k1_ecmult_pippenger_batch_single
static int secp256k1_ecmult_pippenger_batch_single(const secp256k1_callback *error_callback, const secp256k1_ecmult_context *actx, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n)
Definition: ecmult_impl.h:944
run_ecmult_multi_bench
static void run_ecmult_multi_bench(bench_data *data, size_t count, int includes_g, int num_iters)
Definition: bench_ecmult.c:249
secp256k1_sha256_initialize
static void secp256k1_sha256_initialize(secp256k1_sha256 *hash)
bench_ecmult_multi
static void bench_ecmult_multi(void *arg, int iters)
Definition: bench_ecmult.c:201
get_iters
int get_iters(int default_iters)
Definition: bench.h:124
bench_data::scratch
secp256k1_scratch_space * scratch
Definition: bench_ecmult.c:39
secp256k1_context_struct::error_callback
secp256k1_callback error_callback
Definition: secp256k1.c:79
secp256k1_gej_add_var
static void secp256k1_gej_add_var(secp256k1_gej *r, const secp256k1_gej *a, const secp256k1_gej *b, secp256k1_fe *rzr)
Set r equal to the sum of a and b.
bench_ecmult_const_teardown
static void bench_ecmult_const_teardown(void *arg, int iters)
Definition: bench_ecmult.c:122
bench_ecmult_1g_teardown
static void bench_ecmult_1g_teardown(void *arg, int iters)
Definition: bench_ecmult.c:152
bench_data::seckeys
secp256k1_scalar * seckeys
Definition: bench_ecmult.c:43
secp256k1_ecmult_multi_var
static int secp256k1_ecmult_multi_var(const secp256k1_callback *error_callback, const secp256k1_ecmult_context *ctx, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n)
Multi-multiply: R = inp_g_sc * G + sum_i ni * Ai.
secp256k1_ge_set_all_gej_var
static void secp256k1_ge_set_all_gej_var(secp256k1_ge *r, const secp256k1_gej *a, size_t len)
Set a batch of group elements equal to the inputs given in jacobian coordinates.
bench_data
Definition: bench_ecmult.c:36
secp256k1_scalar_clear
static void secp256k1_scalar_clear(secp256k1_scalar *r)
Clear a scalar to prevent the leak of sensitive data.
scalar_impl.h
secp256k1_gej_double_var
static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_gej *a, secp256k1_fe *rzr)
Set r equal to the double of a.
run_ecmult_bench
static void run_ecmult_bench(bench_data *data, int iters)
Definition: bench_ecmult.c:171
bench_data::includes_g
int includes_g
Definition: bench_ecmult.c:49
bench_data::ctx
secp256k1_context * ctx
Definition: bench_ecmult.c:38
bench_ecmult_gen
static void bench_ecmult_gen(void *arg, int iters)
Definition: bench_ecmult.c:99
secp256k1_scalar_mul
static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b)
Multiply two scalars (modulo the group order).
secp256k1_gej_is_infinity
static int secp256k1_gej_is_infinity(const secp256k1_gej *a)
Check whether a group element is the point at infinity.
secp256k1_strauss_scratch_size
static size_t secp256k1_strauss_scratch_size(size_t n_points)
Definition: ecmult_impl.h:577
secp256k1_ecmult_multi_func
int(* secp256k1_ecmult_multi_func)(const secp256k1_callback *error_callback, const secp256k1_ecmult_context *, secp256k1_scratch *, secp256k1_gej *, const secp256k1_scalar *, secp256k1_ecmult_multi_callback cb, void *, size_t)
Definition: ecmult_impl.h:1034
generate_scalar
static void generate_scalar(uint32_t num, secp256k1_scalar *scalar)
Definition: bench_ecmult.c:233
bench_ecmult_1g
static void bench_ecmult_1g(void *arg, int iters)
Definition: bench_ecmult.c:141
main
int main(int argc, char **argv)
Definition: bench_ecmult.c:277
bench_ecmult_teardown_helper
static void bench_ecmult_teardown_helper(bench_data *data, size_t *seckey_offset, size_t *scalar_offset, size_t *scalar_gen_offset, int iters)
Definition: bench_ecmult.c:68
CHECK
#define CHECK(cond)
Definition: util.h:53
secp256k1_scalar_set_b32
static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *bin, int *overflow)
Set a scalar from a big endian byte array.
bench_data::pubkeys
secp256k1_ge * pubkeys
Definition: bench_ecmult.c:41
secp256k1_ge
A group element of the secp256k1 curve, in affine coordinates.
Definition: group.h:13
bench_ecmult_1_teardown
static void bench_ecmult_1_teardown(void *arg, int iters)
Definition: bench_ecmult.c:136
have_flag
int have_flag(int argc, char **argv, char *flag)
Definition: bench.h:109
bench_ecmult_const
static void bench_ecmult_const(void *arg, int iters)
Definition: bench_ecmult.c:113
secp256k1_scalar_set_int
static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v)
Set a scalar to an unsigned integer.
secp256k1_gej_set_ge
static void secp256k1_gej_set_ge(secp256k1_gej *r, const secp256k1_ge *a)
Set a group element (jacobian) equal to another which is given in affine coordinates.