From 285ca97121db58b4b475b6db6c32711311fd9bd7 Mon Sep 17 00:00:00 2001 From: Hannes Mehnert Date: Tue, 13 Feb 2024 16:37:29 +0100 Subject: [PATCH] EC article --- articles/speeding-ec-string.md | 98 + images/trace-cstruct-440.svg | 3861 ++++++++++++++++++++++++++++++++ images/trace-string-770.svg | 2709 ++++++++++++++++++++++ 3 files changed, 6668 insertions(+) create mode 100644 articles/speeding-ec-string.md create mode 100644 images/trace-cstruct-440.svg create mode 100644 images/trace-string-770.svg diff --git a/articles/speeding-ec-string.md b/articles/speeding-ec-string.md new file mode 100644 index 0000000..d343aba --- /dev/null +++ b/articles/speeding-ec-string.md @@ -0,0 +1,98 @@ +--- +date: 2024-02-13 +article.title: Speeding elliptic curve cryptography +article.description: + How we improved the performance of elliptic curves by only modifying the underlying byte array +tags: + - OCaml + - MirageOS + - cryptography + - security +author: + name: Hannes Mehnert + email: hannes@mehnert.org + link: https://hannes.robur.coop +--- + +TL;DR: replacing cstruct with string, we gain a factor of 2.5 in performance. + +## Mirage-crypto-ec + +In April 2021 We published our implementation of [elliptic curve cryptography](https://hannes.robur.coop/Posts/EC) (as `mirage-crypto-ec` opam package) - this is DSA and DH for NIST curves P224, P256, P384, and P521, and also Ed25519 (EdDSA) and X25519 (ECDH). We use [fiat-crypto](https://github.com/mit-plv/fiat-crypto/) for the cryptographic primitives, which emits C code that by construction is free of timing side channels (by not having any data-dependent branches). More C code (such as `point_add`, `point_double`, and further 25519 computations including tables) have been taken from the BoringSSL code base. A lot of OCaml code originates from our TLS 1.3 work in 2018, where Etienne Millon, Nathan Rebours, and Clément Pascutto interfaced [elliptic curves for OCaml](https://github.com/mirage/fiat/) (with the goal of being usable with MirageOS). + +The goal of mirage-crypto-ec was: develop elliptic curve support for OCaml & MirageOS quickly - which didn't leave much time to focus on performance. As time goes by, our mileage varies, and we're keen to use fewer resources - and thus fewer CPU time and a smaller memory footprint is preferable. + +## Memory allocation and calls to C + +OCaml uses managed memory with a generational copying collection. To safely call a C function at any point in time when the arguments are OCaml values (memory allocated on the OCaml heap), it is crucial that while the C function is executed, the arguments should stay at the same memory location, and not being moved by the GC. Otherwise the C code may be upset retrieving wrong data or accessing unmapped memory. + +There are several strategies to achieve this, ranging from "let's use another memory area where the GC doesn't mess around with", "do not run any GC while executing the C code" (read further in the OCaml [cheaper C calls](https://v2.ocaml.org/releases/4.14/htmlman/intfc.html#ss:c-direct-call) manual), "deeply copy the arguments to a non-moving memory area before executing C code", and likely others. + +For our elliptic curve operations, the C code is pretty simple - there are no memory allocations happening in C, neither are exceptions raised. Also, the execution time of the code is constant and pretty small. + +## ocaml-cstruct + +In the [MirageOS](https://mirage.io) ecosystem, a core library is [cstruct](https://github.com/mirage/ocaml-cstruct) - which purpose is manifold: provide ppx rewriters to define C structure layouts in OCaml (getter/setter functions are generated), as well as enums; also a fundamental idea is to use OCaml bigarray which is non-moving memory not allocated on the OCaml heap but directly by calling `malloc`. The memory can even be page-aligned, as required by some C software, such as Xen. Convenient functionality, such as "retrieve a big-endian unsigned 32 bit integer from offset X in this buffer" are provided as well. + +But there's a downside to it - as time moves along, Xen is no longer the only target for MirageOS, and other virtualization mechanisms (such as KVM / virtio) do not require page-aligned memory ranges that are retained at a given memory address. It also turns out that cstruct spends a lot of time in bounds checks. Another huge downside is that OCaml tooling (such as statmemprof) was for a long time (maybe still is not?) unaware of out-of-OCaml-GC allocated memory (cstruct uses bigarray as underlying buffer). Freeing up the memory requires finalizers to be executed - after all pretty tedious (expensive) and against the OCaml runtime philosophy. + +As time moves forward, also the OCaml standard library got support for (a) strings are immutable byte vectors now (since 4.06 - released in 2017 -- there's as well an interface for mutable/immutable cstruct, but that is not used as far as I can tell), (b) retrieve a certain amount of octets in a string or byte as (unsigned) integer number (since 4.08 - released in 2019, while some additional functionality is only available in 4.13). + +Still, bigarrays are necessary in certain situations - if you need to have a non-moving (shared) area of memory, as in the Xen interface, but also e.g. when you compute in parallel in different processes, or when you need mmap()ed files. + +## Putting it together + +Already in October 2021, Romain [proposed](https://github.com/mirage/mirage-crypto/pull/146) to not use cstruct, but bytes for mirage-crypto-ec. The PR was sitting around since there were benchmarks missing, and developer time was small. But recently, Virgile Robles [proposed](https://github.com/mirage/mirage-crypto/pull/191) another line of work to use pre-computed tables for NIST curves to speed up the elliptic curve cryptography. Conducting performance evaluation resulted that the "use bytes instead of cstruct" combined with pre-computed tables made a huge difference (factor of 6) compared to the latest release. + +To ease reviewing changes, we decided to focus on landing the "use bytes instead of cstruct" first, and gladly Pierre Alain had already rebased the existing patch onto the latest release of mirage-crypto-ec. We also went further and use string where applicable instead of bytes. For safety reasons we also introduced an API layer which (a) allocates a byte vector for the result (b) calls the primitive, and \(c) transforms the byte vector into an immutable string. This API is more in line with functional programming (immutable values), and since allocations and deallocations of values are cheap, there's no measurable performance decrease. + +All the changes are internal, there's no external API that needs to be adjusted - still there's at the API boundary one conversion of cstruct to string (and back for the return value) done. + +We used `perf` to construct some flame graphs (of the ECDSA P256 sign), shown below. + +![Flamegraph of ECDSA sign with cstruct](../images/trace-cstruct-440.svg) + +The flame graph of P256 ECDSA sign using the mirage-crypto release 0.11.2. The majority of time is spent in "do_sign", which calls `inv` (inversion), `scalar_mult` (majority of time), and `x_of_finite_point_mod_n`. The scalar multiplication spends time in `add`, `double` and `select`. Several towers starting at `Cstruct.create_919` are visible. + +With PR#146, the flame graph looks different: + +![Flamegraph of ECDSA sign with string](../images/trace-string-770.svg) + +Now, the allocation towers do not exist anymore. The time of a sign operation is spend in `inv`, `scalar_mult`, and `x_of_finite_point_mod_n`. There's still room for improvements in these operations. + +## Performance numbers + +All numbers were gathered on a Lenovo X250 laptop with a Intel i7-5600U CPU @ 2.60GHz. We used OCaml 4.14.1 as compiler. The baseline is OpenSSL 3.0.12. All numbers are in operations per second. + +NIST P-256 + +| op | 0.11.2 | PR#146 | speedup | OpenSSL | speedup | +| - | - | - | - | - | - | +| sign | 748 | 1806 | 2.41x | 34392 | 19.04x | +| verify | 285 | 655 | 2.30x | 12999 | 19.85x | +| ecdh | 858 | 1785 | 2.08x | 16514 | 9.25x | + +Curve 25519 + +| op | 0.11.2 | PR#146 | speedup | OpenSSL | speedup | +| - | - | - | - | - | - | +| sign | 10713 | 11560 | 1.08x | 21943 | 1.90x | +| verify | 7600 | 8314 | 1.09x | 7081 | 0.85x | +| ecdh | 12144 | 13457 | 1.11x | 26201 | 1.95x | + + +Note: to re-create the performance numbers, you can run `openssl speed ecdsap256 ecdhp256 ed25519 ecdhx25519` - for the OCaml site, use `dune bu bench/speed.exe --rel` and `_build/default/bench/speed.exe ecdsa-sign ecdsa-verify ecdh-share`. + +The performance improvements are up to 2.5 times compared to the latest mirage-crypto-ec release (look at the 4th column). In comparison to OpenSSL, we still lack a factor of 20 for the NIST curves, and up to a factor of 2 for 25519 computations (look at the last column). + +If you have ideas for improvements, let us know via an issue, eMail, or a pull request :) We started to [gather some](https://github.com/mirage/mirage-crypto/issues/193) for 25519 by comparing our code with changes in BoringSSL over the last years. + +As a spoiler, for P-256 sign there's another improvement of around 4.5 with [Virgile's PR](https://github.com/mirage/mirage-crypto/pull/191) using pre-computed tables also for NIST curves. + +## The road ahead for 2024 + +Remove all cstruct, everywhere, apart from in mirage-block-xen and mirage-net-xen ;). It was a fine decision in the early MirageOS days, but from a performance point of view, and for making our packages more broadly usable without many dependencies, it is time to remove cstruct. Earlier this year we already [removed cstruct from ocaml-tar](https://github.com/mirage/ocaml-tar/pull/137) for similar reasons. + +Our MirageOS work is only partially funded, we cross-fund our work by commercial contracts and public (EU) funding. We are part of a non-profit company, you can make a (tax-deducable - at least in the EU) [donation](https://aenderwerk.de/donate/) (select "DONATION robur" in the dropdown menu). + +We're keen to get MirageOS deployed in production - if you would like to do that, don't hesitate to reach out to us via eMail team at robur.coop \ No newline at end of file diff --git a/images/trace-cstruct-440.svg b/images/trace-cstruct-440.svg new file mode 100644 index 0000000..a14d520 --- /dev/null +++ b/images/trace-cstruct-440.svg @@ -0,0 +1,3861 @@ + + + + + + + + + + + + + + +Flame Graph + +Reset Zoom +Search +ic + + + +Mirage_crypto.Hash.fun_1807 (6,364,869 samples, 0.02%) + + + +checked_request2size (3,164,328 samples, 0.01%) + + + +__gmpz_probab_prime_p (7,638,867 samples, 0.02%) + + + +caml_ba_alloc (779,918,409 samples, 2.44%) +ca.. + + +Mirage_crypto_ec.bit_at_293 (26,343,003 samples, 0.08%) + + + +fiat_np256_addcarryx_u64 (5,059,916 samples, 0.02%) + + + +ror32 (3,799,878 samples, 0.01%) + + + +Mirage_crypto_ec.to_affine_raw_785 (744,954,275 samples, 2.33%) +M.. + + +fiat_p521_mul (5,685,519 samples, 0.02%) + + + +caml_alloc_custom_mem (702,780,418 samples, 2.20%) +c.. + + +fiat_p256_sub (44,838,455 samples, 0.14%) + + + +Mirage_crypto_ec.fun_3441 (6,256,530 samples, 0.02%) + + + +_int_free (50,055,209 samples, 0.16%) + + + +malloc@plt (7,561,459 samples, 0.02%) + + + +Mirage_crypto_pk.Z_extra.pseudoprime_251 (19,762,356 samples, 0.06%) + + + +__gmpz_lucas_mod (6,369,264 samples, 0.02%) + + + +mc_np256_to_montgomery (3,805,013 samples, 0.01%) + + + +Mirage_crypto_ec.one_696 (6,876,143 samples, 0.02%) + + + +caml_ba_finalize (3,717,916 samples, 0.01%) + + + +caml_fill_bigstring (16,358,734 samples, 0.05%) + + + +__GI___libc_free (96,852,199 samples, 0.30%) + + + +task_sched_runtime (6,971,764 samples, 0.02%) + + + +fiat_p256_addcarryx_u64 (2,491,951,169 samples, 7.79%) +fiat_p256_.. + + +caml_fill_bigstring (34,072,487 samples, 0.11%) + + + +caml_alloc_custom_mem (714,621,939 samples, 2.23%) +c.. + + +Cstruct.create_unsafe_790 (3,131,274 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1737 (15,684,380 samples, 0.05%) + + + +caml_ba_finalize (141,403,540 samples, 0.44%) + + + +caml_gc_dispatch (3,823,091 samples, 0.01%) + + + +__GI___libc_free (43,524,341 samples, 0.14%) + + + +checked_request2size (4,435,928 samples, 0.01%) + + + +__memcpy_avx_unaligned_erms (59,959,547 samples, 0.19%) + + + +Mirage_crypto.Uncommon.clone_338 (3,770,238 samples, 0.01%) + + + +mc_p256_select (5,638,900 samples, 0.02%) + + + +Mirage_crypto.Hash.feedi_558 (28,960,623 samples, 0.09%) + + + +caml_gc_dispatch (200,780,461 samples, 0.63%) + + + +caml_alloc_custom_mem (3,173,938 samples, 0.01%) + + + +arena_for_chunk (3,825,893 samples, 0.01%) + + + +__GI___libc_free (116,752,065 samples, 0.36%) + + + +caml_ba_finalize (260,465,754 samples, 0.81%) + + + +Cstruct.rev_1405 (7,008,218 samples, 0.02%) + + + +Cstruct.create_unsafe_790 (10,134,229 samples, 0.03%) + + + +inversion (725,414,236 samples, 2.27%) +i.. + + +free@plt (4,466,613 samples, 0.01%) + + + +caml_memprof_track_custom (18,338,308 samples, 0.06%) + + + +caml_check_urgent_gc (4,407,119 samples, 0.01%) + + + +caml_ba_update_proxy (330,980,805 samples, 1.03%) + + + +_start (28,892,769,346 samples, 90.28%) +_start + + +caml_alloc_custom_mem (3,801,402 samples, 0.01%) + + + +Mirage_crypto_ec.do_sign_1128 (4,452,368 samples, 0.01%) + + + +memset (30,884,394 samples, 0.10%) + + + +Mirage_crypto.Hash.finalize_545 (3,763,200 samples, 0.01%) + + + +__gmpz_millerrabin (7,619,571 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (74,682,796 samples, 0.23%) + + + +caml_ba_get_1 (4,464,953 samples, 0.01%) + + + +mc_p256_select (6,871,825 samples, 0.02%) + + + +Cstruct.rev_1405 (8,818,079 samples, 0.03%) + + + +caml_alloc_small_dispatch (379,645,112 samples, 1.19%) + + + +ml_z_probab_prime (7,638,867 samples, 0.02%) + + + +caml_alloc_small (412,350,122 samples, 1.29%) + + + +Mirage_crypto_pk.Rsa.priv_of_primes_502 (7,638,867 samples, 0.02%) + + + +__gmpn_strongfibo (12,736,195 samples, 0.04%) + + + +__gmpz_lucas_mod (5,749,534 samples, 0.02%) + + + +inverse (725,414,236 samples, 2.27%) +i.. + + +Mirage_crypto.Hash.fun_1809 (15,204,742 samples, 0.05%) + + + +point_double (15,218,805 samples, 0.05%) + + + +__handle_mm_fault (3,066,333 samples, 0.01%) + + + +fiat_p256_sub (9,479,642 samples, 0.03%) + + + +Cstruct.create_919 (12,706,545 samples, 0.04%) + + + +_mc_sha256_update (15,684,380 samples, 0.05%) + + + +memset (28,352,912 samples, 0.09%) + + + +sha256_do_chunk (13,923,937 samples, 0.04%) + + + +point_double (7,153,224,922 samples, 22.35%) +point_double + + +inverse (13,940,932 samples, 0.04%) + + + +__GI___libc_free (61,021,556 samples, 0.19%) + + + +[speed.exe] (162,870,201 samples, 0.51%) + + + +fiat_p521_addcarryx_u64 (8,250,208 samples, 0.03%) + + + +Stdlib.Bigarray.create_379 (7,610,951 samples, 0.02%) + + + +caml_ba_update_proxy (39,795,478 samples, 0.12%) + + + +fiat_p256_mulx_u64 (674,283,609 samples, 2.11%) +f.. + + +caml_alloc_small_dispatch (128,825,989 samples, 0.40%) + + + +caml_memprof_track_custom (16,968,600 samples, 0.05%) + + + +_int_free (86,244,256 samples, 0.27%) + + + +fiat_p256_square (3,335,304,439 samples, 10.42%) +fiat_p256_square + + +caml_ba_finalize (3,182,102 samples, 0.01%) + + + +caml_ba_sub (11,266,249 samples, 0.04%) + + + +asm_sysvec_apic_timer_interrupt (4,451,710 samples, 0.01%) + + + +handle_mm_fault (3,066,333 samples, 0.01%) + + + +caml_empty_minor_heap (384,149,022 samples, 1.20%) + + + +Cstruct.to_bigarray_787 (3,721,575 samples, 0.01%) + + + +checked_request2size (6,970,843 samples, 0.02%) + + + +__gmpn_redc_1 (31,141,857 samples, 0.10%) + + + +caml_apply2 (3,048,824 samples, 0.01%) + + + +Mirage_crypto_pk.Rsa.valid_prime_447 (7,638,867 samples, 0.02%) + + + +point_double (55,431,312 samples, 0.17%) + + + +Cstruct.create_unsafe_790 (20,218,893 samples, 0.06%) + + + +caml_call_gc (396,062,506 samples, 1.24%) + + + +alloc_custom_gen (105,441,134 samples, 0.33%) + + + +caml_ba_alloc (3,800,379 samples, 0.01%) + + + +Cstruct.rev_1405 (7,628,390 samples, 0.02%) + + + +mc_sha256_finalize (3,155,179 samples, 0.01%) + + + +mark_slice (3,114,403 samples, 0.01%) + + + +__GI___libc_free (20,955,240 samples, 0.07%) + + + +_int_malloc (19,086,325 samples, 0.06%) + + + +Stdlib.Bigarray.create_379 (854,420,419 samples, 2.67%) +St.. + + +fiat_p256_mul (48,433,742 samples, 0.15%) + + + +caml_alloc_custom_mem (328,925,493 samples, 1.03%) + + + +Cstruct.create_919 (8,914,380 samples, 0.03%) + + + +Mirage_crypto.Hash.fun_1807 (23,950,156 samples, 0.07%) + + + +_mc_sha256_update (18,958,865 samples, 0.06%) + + + +elf_dynamic_do_Rela (5,206,101 samples, 0.02%) + + + +_mc_sha256_update (7,028,208 samples, 0.02%) + + + +caml_fill_bigstring (3,735,187 samples, 0.01%) + + + +fiat_p256_value_barrier_u64 (3,170,051 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (6,950,198 samples, 0.02%) + + + +Mirage_crypto.Hash.finalize_545 (17,758,243 samples, 0.06%) + + + +thread_group_cputime_adjusted (12,680,532 samples, 0.04%) + + + +__GI___libc_free (71,248,632 samples, 0.22%) + + + +Mirage_crypto.Uncommon.xor_into_345 (3,048,204 samples, 0.01%) + + + +__GI___libc_free (49,036,145 samples, 0.15%) + + + +fiat_p256_square (3,197,963 samples, 0.01%) + + + +caml_ba_create (1,749,647,949 samples, 5.47%) +caml_ba.. + + +__GI___libc_malloc (643,867,949 samples, 2.01%) +_.. + + +_int_free (17,776,234 samples, 0.06%) + + + +Mirage_crypto_pk.Z_extra.pseudoprime_251 (8,252,278 samples, 0.03%) + + + +caml_gc_dispatch (3,823,575 samples, 0.01%) + + + +__gmpn_sbpi1_div_qr (4,451,740 samples, 0.01%) + + + +caml_ba_sub (3,718,234 samples, 0.01%) + + + +Mirage_crypto_pk.Rsa.fun_2060 (8,252,278 samples, 0.03%) + + + +Cstruct.create_unsafe_790 (5,072,347 samples, 0.02%) + + + +caml_gc_dispatch (433,072,481 samples, 1.35%) + + + +Cstruct.create_unsafe_790 (2,203,723,303 samples, 6.89%) +Cstruct.c.. + + +Cstruct.create_unsafe_790 (3,817,576 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3491 (725,414,236 samples, 2.27%) +M.. + + +__GI___libc_free (208,675,127 samples, 0.65%) + + + +caml_ba_alloc (3,809,391 samples, 0.01%) + + + +caml_apply4 (13,259,500 samples, 0.04%) + + + +Mirage_crypto.Uncommon.clone_338 (23,381,460 samples, 0.07%) + + + +_int_free (43,141,857 samples, 0.13%) + + + +_int_malloc (8,857,534 samples, 0.03%) + + + +__gmpz_stronglucas (7,619,571 samples, 0.02%) + + + +caml_call_gc (190,185,589 samples, 0.59%) + + + +caml_ba_finalize (268,363,604 samples, 0.84%) + + + +caml_ba_finalize (10,125,725 samples, 0.03%) + + + +caml_ba_sub (19,714,643 samples, 0.06%) + + + +Mirage_crypto_pk.Dsa.fun_997 (19,762,356 samples, 0.06%) + + + +caml_ba_get_1 (6,243,855 samples, 0.02%) + + + +caml_alloc_small_dispatch (3,823,091 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3441 (224,698,663 samples, 0.70%) + + + +__GI___libc_free (18,420,928 samples, 0.06%) + + + +Mirage_crypto_ec.add_815 (22,237,216 samples, 0.07%) + + + +caml_empty_minor_heap (370,766,144 samples, 1.16%) + + + +sha256_do_chunk (18,958,865 samples, 0.06%) + + + +Cstruct.create_unsafe_790 (3,809,391 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3048 (8,772,304 samples, 0.03%) + + + +Dune.exe.Speed.go_236 (2,531,788,015 samples, 7.91%) +Dune.exe.Sp.. + + +caml_ba_finalize (4,434,436 samples, 0.01%) + + + +caml_ba_finalize (269,010,013 samples, 0.84%) + + + +_int_free (13,315,549 samples, 0.04%) + + + +caml_ba_alloc (19,581,123 samples, 0.06%) + + + +caml_empty_minor_heap (4,434,436 samples, 0.01%) + + + +caml_ba_alloc (6,985,532 samples, 0.02%) + + + +Mirage_crypto_pk.Dh.s_group_489 (3,891,166 samples, 0.01%) + + + +fiat_p256_addcarryx_u64 (269,776,854 samples, 0.84%) + + + +__memset_avx2_unaligned_erms (10,662,221 samples, 0.03%) + + + +__memset_avx2_unaligned_erms (24,527,772 samples, 0.08%) + + + +Cstruct.create_unsafe_790 (3,182,238 samples, 0.01%) + + + +caml_alloc_small (3,823,091 samples, 0.01%) + + + +free@plt (5,095,248 samples, 0.02%) + + + +Mirage_crypto.Hash.fun_1737 (29,531,370 samples, 0.09%) + + + +ror32 (3,797,089 samples, 0.01%) + + + +caml_ba_create (3,770,238 samples, 0.01%) + + + +inverse (8,883,355 samples, 0.03%) + + + +mc_sha256_finalize (13,933,005 samples, 0.04%) + + + +__gmpn_fib2m (12,101,686 samples, 0.04%) + + + +Cstruct.to_bigarray_787 (6,341,598 samples, 0.02%) + + + +caml_ba_finalize (130,465,944 samples, 0.41%) + + + +caml_startup_common (28,886,108,386 samples, 90.26%) +caml_startup_common + + +do_user_addr_fault (3,790,995 samples, 0.01%) + + + +_int_malloc (3,166,315 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1807 (6,056,180 samples, 0.02%) + + + +do_syscall_64 (36,800,621 samples, 0.11%) + + + +free@plt (7,607,948 samples, 0.02%) + + + +Mirage_crypto.Hash.feedi_558 (64,735,412 samples, 0.20%) + + + +ror32 (4,991,707 samples, 0.02%) + + + +asm_exc_page_fault (3,790,995 samples, 0.01%) + + + +fiat_p256_nonzero (5,699,290 samples, 0.02%) + + + +inversion (722,844,990 samples, 2.26%) +i.. + + +free@plt (4,458,823 samples, 0.01%) + + + +_mc_sha256_update (6,056,180 samples, 0.02%) + + + +caml_ba_create (5,701,678 samples, 0.02%) + + + +Cstruct.rev_1405 (6,241,259 samples, 0.02%) + + + +caml_ba_create (1,715,925,918 samples, 5.36%) +caml_b.. + + +caml_alloc_small (33,629,609 samples, 0.11%) + + + +__GI___libc_free (195,832,449 samples, 0.61%) + + + +sha256_do_chunk (20,085,810 samples, 0.06%) + + + +caml_ba_alloc (919,395,340 samples, 2.87%) +ca.. + + +Mirage_crypto.Hash.finalize_545 (27,844,491 samples, 0.09%) + + + +alloc_custom_gen (280,796,212 samples, 0.88%) + + + +fiat_p256_sub (421,856,748 samples, 1.32%) + + + +caml_ba_update_proxy (641,477,253 samples, 2.00%) +c.. + + +Mirage_crypto_ec.share_inner_3065 (52,688,772 samples, 0.16%) + + + +__GI___libc_malloc (597,139,124 samples, 1.87%) +_.. + + +Mirage_crypto_ec.scalar_mult_932 (4,426,102 samples, 0.01%) + + + +asm_sysvec_apic_timer_interrupt (3,821,445 samples, 0.01%) + + + +Mirage_crypto_ec.add_815 (8,420,850,600 samples, 26.31%) +Mirage_crypto_ec.add_815 + + +__getrusage (62,154,425 samples, 0.19%) + + + +caml_alloc_small (464,839,194 samples, 1.45%) + + + +caml_alloc_small_dispatch (4,434,436 samples, 0.01%) + + + +caml_c_call (39,119,826 samples, 0.12%) + + + +caml_gc_dispatch (187,631,333 samples, 0.59%) + + + +__sysvec_apic_timer_interrupt (5,505,601 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3048 (3,815,437 samples, 0.01%) + + + +_dl_start (6,027,808 samples, 0.02%) + + + +_mc_sha256_update (13,923,937 samples, 0.04%) + + + +_int_free (12,112,610 samples, 0.04%) + + + +fiat_np256_mul (5,101,229 samples, 0.02%) + + + +__GI___libc_free (175,092,256 samples, 0.55%) + + + +caml_alloc_small (96,969,234 samples, 0.30%) + + + +mc_sha256_finalize (18,958,865 samples, 0.06%) + + + +Stdlib.Bigarray.create_379 (20,938,942 samples, 0.07%) + + + +Mirage_crypto_ec.x_of_finite_point_mod_n_1115 (773,362,855 samples, 2.42%) +Mi.. + + +caml_c_call (3,100,196 samples, 0.01%) + + + +fiat_np256_subborrowx_u64 (208,350,120 samples, 0.65%) + + + +checked_request2size (5,092,133 samples, 0.02%) + + + +caml_memprof_track_custom (13,788,628 samples, 0.04%) + + + +caml_ba_get_N (4,464,953 samples, 0.01%) + + + +__GI___libc_free (3,740,043 samples, 0.01%) + + + +_mc_sha256_finalize (13,933,005 samples, 0.04%) + + + +fiat_p256_subborrowx_u64 (241,653,448 samples, 0.76%) + + + +caml_empty_minor_heap (391,628,179 samples, 1.22%) + + + +caml_alloc_small_dispatch (438,130,108 samples, 1.37%) + + + +alloc_custom_gen (297,088,408 samples, 0.93%) + + + +caml_alloc_custom_mem (3,792,136 samples, 0.01%) + + + +malloc@plt (9,447,704 samples, 0.03%) + + + +dl_main (6,027,808 samples, 0.02%) + + + +caml_apply3 (11,445,062 samples, 0.04%) + + + +Cstruct.to_bigarray_787 (6,286,533 samples, 0.02%) + + + +__x64_sys_getrusage (16,497,050 samples, 0.05%) + + + +Mirage_crypto.Hash.fun_1809 (13,933,005 samples, 0.04%) + + + +mc_p256_point_add (39,585,335 samples, 0.12%) + + + +Mirage_crypto.Uncommon.xor_639 (10,158,335 samples, 0.03%) + + + +mc_p256_point_add (6,422,697,520 samples, 20.07%) +mc_p256_point_add + + +caml_ba_alloc (69,306,055 samples, 0.22%) + + + +fiat_p256_subborrowx_u64 (273,219,540 samples, 0.85%) + + + +Stdlib.Bigarray.create_379 (5,072,347 samples, 0.02%) + + + +__gmpn_tdiv_qr (5,101,296 samples, 0.02%) + + + +caml_ba_get_N (5,626,766 samples, 0.02%) + + + +alloc_custom_gen (3,197,534 samples, 0.01%) + + + +caml_gc_dispatch (384,149,022 samples, 1.20%) + + + +_int_free (105,007,378 samples, 0.33%) + + + +Mirage_crypto_pk.Dsa.priv_342 (20,395,547 samples, 0.06%) + + + +_int_free (57,778,137 samples, 0.18%) + + + +caml_c_call (30,360,294 samples, 0.09%) + + + +inverse (722,844,990 samples, 2.26%) +i.. + + +sysvec_apic_timer_interrupt (4,451,710 samples, 0.01%) + + + +fiat_p256_mul (2,129,829,720 samples, 6.65%) +fiat_p256.. + + +Stdlib.Bigarray.create_379 (20,218,893 samples, 0.06%) + + + +Stdlib.Bigarray.create_379 (3,770,238 samples, 0.01%) + + + +free@plt (5,719,455 samples, 0.02%) + + + +caml_ba_create (3,809,391 samples, 0.01%) + + + +caml_alloc_small_dispatch (422,713,306 samples, 1.32%) + + + +tcache_get (19,461,560 samples, 0.06%) + + + +Dune.exe.Speed.entry (28,878,232,543 samples, 90.23%) +Dune.exe.Speed.entry + + +Mirage_crypto.Hash.feedi_558 (13,076,956 samples, 0.04%) + + + +_dl_sysdep_start (6,027,808 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3443 (7,204,879,953 samples, 22.51%) +Mirage_crypto_ec.fun_3443 + + +memset (20,153,192 samples, 0.06%) + + + +_int_free (55,810,945 samples, 0.17%) + + + +Mirage_crypto_ec.scalar_mult_932 (24,322,712,376 samples, 76.00%) +Mirage_crypto_ec.scalar_mult_932 + + +caml_empty_minor_heap (433,072,481 samples, 1.35%) + + + +caml_c_call (11,759,553 samples, 0.04%) + + + +caml_main (28,886,108,386 samples, 90.26%) +caml_main + + +_mc_sha256_finalize (18,958,865 samples, 0.06%) + + + +__GI___libc_malloc (309,443,162 samples, 0.97%) + + + +Stdlib.Bigarray.create_379 (10,172,105 samples, 0.03%) + + + +arena_for_chunk (3,188,954 samples, 0.01%) + + + +_int_free (59,040,360 samples, 0.18%) + + + +fiat_p256_divstep (6,844,240 samples, 0.02%) + + + +fiat_p256_subborrowx_u64 (129,146,793 samples, 0.40%) + + + +Mirage_crypto_ec.select_826 (4,444,870 samples, 0.01%) + + + +Mirage_crypto_ec.double_811 (27,282,354 samples, 0.09%) + + + +caml_alloc_small (227,288,144 samples, 0.71%) + + + +caml_alloc_custom_mem (337,484,409 samples, 1.05%) + + + +sha256_do_chunk (4,400,412 samples, 0.01%) + + + +memcpy@plt (17,708,950 samples, 0.06%) + + + +caml_ba_create (835,512,245 samples, 2.61%) +ca.. + + +caml_ba_alloc (4,375,570 samples, 0.01%) + + + +tcache_get (22,078,077 samples, 0.07%) + + + +caml_ba_create (7,654,925 samples, 0.02%) + + + +caml_alloc_custom_mem (5,752,120 samples, 0.02%) + + + +caml_ba_alloc (5,039,541 samples, 0.02%) + + + +__gmpn_sqr_basecase (93,628,787 samples, 0.29%) + + + +_int_free (30,527,788 samples, 0.10%) + + + +caml_empty_minor_heap (126,931,342 samples, 0.40%) + + + +caml_alloc_custom_mem (719,229,546 samples, 2.25%) +c.. + + +mc_p521_point_add (13,953,910 samples, 0.04%) + + + +__gmpn_submul_1 (77,762,094 samples, 0.24%) + + + +Stdlib.Bigarray.create_379 (4,447,011 samples, 0.01%) + + + +caml_c_call (7,593,360 samples, 0.02%) + + + +__memcpy_avx_unaligned_erms (35,456,317 samples, 0.11%) + + + +caml_ba_alloc (420,205,614 samples, 1.31%) + + + +fiat_p256_cmovznz_u64 (41,563,341 samples, 0.13%) + + + +caml_alloc_string (3,767,353 samples, 0.01%) + + + +free@plt (4,465,549 samples, 0.01%) + + + +Dune.exe.Speed.fun_2371 (26,249,204,063 samples, 82.02%) +Dune.exe.Speed.fun_2371 + + +caml_empty_minor_heap (4,407,119 samples, 0.01%) + + + +Cstruct.blit_870 (3,162,567 samples, 0.01%) + + + +caml_ba_alloc (7,654,925 samples, 0.02%) + + + +caml_empty_minor_heap (3,823,091 samples, 0.01%) + + + +caml_empty_minor_heap (3,823,575 samples, 0.01%) + + + +syscall_return_via_sysret (12,031,677 samples, 0.04%) + + + +__gmpn_sbpi1_div_qr (7,022,180 samples, 0.02%) + + + +_mc_sha256_update (20,085,810 samples, 0.06%) + + + +__GI___libc_free (189,811,193 samples, 0.59%) + + + +__gmpn_strongfibo (6,980,668 samples, 0.02%) + + + +exc_page_fault (3,790,995 samples, 0.01%) + + + +fiat_p256_addcarryx_u64 (2,210,551,331 samples, 6.91%) +fiat_p256.. + + +__GI___libc_free (65,843,229 samples, 0.21%) + + + +caml_memprof_track_custom (20,922,560 samples, 0.07%) + + + +__hrtimer_run_queues (4,871,031 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3598 (4,462,759 samples, 0.01%) + + + +sha256_do_chunk (6,388,881 samples, 0.02%) + + + +fiat_np256_divstep (714,802,381 samples, 2.23%) +f.. + + +caml_empty_minor_heap (40,059,893 samples, 0.13%) + + + +ml_z_probab_prime (19,762,356 samples, 0.06%) + + + +caml_gc_dispatch (370,766,144 samples, 1.16%) + + + +memset (13,215,630 samples, 0.04%) + + + +mc_sha256_update (23,950,156 samples, 0.07%) + + + +Mirage_crypto_ec.fun_3445 (6,424,613,615 samples, 20.07%) +Mirage_crypto_ec.fun_3445 + + +fiat_p256_mul (44,089,845 samples, 0.14%) + + + +memset@plt (6,356,622 samples, 0.02%) + + + +_mc_sha256_finalize (18,925,107 samples, 0.06%) + + + +thread_group_cputime (10,155,617 samples, 0.03%) + + + +memcpy@plt (14,522,033 samples, 0.05%) + + + +Mirage_crypto_ec.fun_3443 (8,209,393 samples, 0.03%) + + + +mc_np256_mul (5,101,229 samples, 0.02%) + + + +_mc_sha256_update (13,933,005 samples, 0.04%) + + + +caml_alloc_small_dispatch (117,499,229 samples, 0.37%) + + + +Eqaf_bigstring.compare_be_434 (4,464,953 samples, 0.01%) + + + +caml_ba_sub (8,793,323 samples, 0.03%) + + + +__gmpz_millerrabin (7,008,158 samples, 0.02%) + + + +__gmpn_dcpi1_div_qr (8,288,174 samples, 0.03%) + + + +[unknown] (1,091,924,693 samples, 3.41%) +[un.. + + +fiat_p256_cmovznz_u64 (79,844,171 samples, 0.25%) + + + +fe_cmovznz (93,050,407 samples, 0.29%) + + + +__gmpn_mul_basecase (31,848,594 samples, 0.10%) + + + +caml_alloc_custom_mem (3,150,661 samples, 0.01%) + + + +__gmpn_tdiv_qr (4,451,740 samples, 0.01%) + + + +caml_empty_minor_heap (200,780,461 samples, 0.63%) + + + +mc_p256_inv (13,940,932 samples, 0.04%) + + + +[[stack]] (403,847,689 samples, 1.26%) + + + +sha256_do_chunk (5,417,250 samples, 0.02%) + + + +__GI___libc_malloc (15,242,690 samples, 0.05%) + + + +hrtimer_interrupt (4,451,710 samples, 0.01%) + + + +Mirage_crypto.Uncommon.xor_639 (26,429,664 samples, 0.08%) + + + +_mc_sha256_update (18,298,601 samples, 0.06%) + + + +Mirage_crypto.Hash.fun_1742 (7,596,443 samples, 0.02%) + + + +mc_xor_into (3,048,204 samples, 0.01%) + + + +_int_free (34,426,413 samples, 0.11%) + + + +Mirage_crypto_ec.to_be_cstruct_1020 (5,609,240 samples, 0.02%) + + + +Mirage_crypto_ec.g_1075 (175,984,199 samples, 0.55%) + + + +Mirage_crypto_ec.select_709 (4,280,588,392 samples, 13.37%) +Mirage_crypto_ec.sel.. + + +caml_major_collection_slice (3,114,403 samples, 0.01%) + + + +caml_gc_dispatch (181,970,605 samples, 0.57%) + + + +tick_sched_timer (3,119,205 samples, 0.01%) + + + +caml_major_collection_slice (3,814,396 samples, 0.01%) + + + +tcache_put (21,491,073 samples, 0.07%) + + + +caml_c_call (4,379,729 samples, 0.01%) + + + +__gmpz_probab_prime_p (19,762,356 samples, 0.06%) + + + +caml_call_gc (389,224,224 samples, 1.22%) + + + +caml_ba_sub (1,745,541,047 samples, 5.45%) +caml_ba.. + + +Mirage_crypto_rng.Hmac_drbg.generate_184 (114,856,449 samples, 0.36%) + + + +fiat_p256_cmovznz_u64 (176,022,712 samples, 0.55%) + + + +Stdlib.Bigarray.create_379 (5,701,678 samples, 0.02%) + + + +Mirage_crypto.Uncommon.clone_338 (7,594,296 samples, 0.02%) + + + +fiat_p256_subborrowx_u64 (300,150,629 samples, 0.94%) + + + +alloc_custom_gen (7,569,189 samples, 0.02%) + + + +fiat_p256_addcarryx_u64 (93,358,535 samples, 0.29%) + + + +fiat_p384_mul (3,824,171 samples, 0.01%) + + + +__GI___libc_malloc (14,301,417 samples, 0.04%) + + + +caml_ba_finalize (4,941,514 samples, 0.02%) + + + +Cstruct.create_unsafe_790 (8,953,633 samples, 0.03%) + + + +__gmpz_stronglucas (18,485,729 samples, 0.06%) + + + +caml_ba_sub (5,014,870 samples, 0.02%) + + + +Mirage_crypto_ec.do_sign_1128 (5,063,094 samples, 0.02%) + + + +caml_ba_update_proxy (9,510,351 samples, 0.03%) + + + +Cstruct.create_unsafe_790 (6,966,111 samples, 0.02%) + + + +tcache_get (30,977,192 samples, 0.10%) + + + +tcache_get (20,673,515 samples, 0.06%) + + + +tcache_put (26,557,320 samples, 0.08%) + + + +caml_alloc_small (410,224,497 samples, 1.28%) + + + +Cstruct.create_919 (2,247,200,498 samples, 7.02%) +Cstruct.c.. + + +caml_ba_finalize (12,284,965 samples, 0.04%) + + + +tcache_put (37,923,037 samples, 0.12%) + + + +mc_p521_point_double (15,218,805 samples, 0.05%) + + + +caml_gc_dispatch (4,487,559 samples, 0.01%) + + + +Stdlib.Bigarray.create_379 (3,809,391 samples, 0.01%) + + + +caml_alloc_custom_mem (3,197,534 samples, 0.01%) + + + +caml_alloc_small_dispatch (182,601,849 samples, 0.57%) + + + +entry_SYSCALL_64_after_hwframe (3,514,586 samples, 0.01%) + + + +Cstruct.to_bigarray_787 (1,758,138,917 samples, 5.49%) +Cstruct.. + + +Mirage_crypto_ec.to_be_cstruct_1020 (4,937,471 samples, 0.02%) + + + +syscall_exit_to_user_mode (18,413,184 samples, 0.06%) + + + +__GI___libc_free (88,053,168 samples, 0.28%) + + + +Cstruct.rev_1405 (3,718,122 samples, 0.01%) + + + +mc_p256_point_double (7,202,358,684 samples, 22.50%) +mc_p256_point_double + + +Mirage_crypto_ec.scalar_mult_932 (5,101,824 samples, 0.02%) + + + +_int_free (8,933,405 samples, 0.03%) + + + +_int_malloc (5,064,646 samples, 0.02%) + + + +mc_sha256_update (20,085,810 samples, 0.06%) + + + +checked_request2size (14,350,656 samples, 0.04%) + + + +caml_alloc_custom_mem (166,607,887 samples, 0.52%) + + + +caml_ba_alloc (1,600,257,770 samples, 5.00%) +caml_b.. + + +caml_gc_dispatch (51,649,754 samples, 0.16%) + + + +Cstruct.create_unsafe_790 (3,770,238 samples, 0.01%) + + + +caml_gc_dispatch (4,430,928 samples, 0.01%) + + + +caml_alloc_small_dispatch (6,368,987 samples, 0.02%) + + + +caml_ba_sub (833,888,784 samples, 2.61%) +ca.. + + +caml_alloc_small_dispatch (4,487,559 samples, 0.01%) + + + +arena_for_chunk (3,150,203 samples, 0.01%) + + + +asm_sysvec_apic_timer_interrupt (3,760,560 samples, 0.01%) + + + +caml_alloc_small (5,053,215 samples, 0.02%) + + + +__GI___libc_free (31,159,801 samples, 0.10%) + + + +tcache_get (34,021,834 samples, 0.11%) + + + +Mirage_crypto_ec.fun_3501 (11,422,835 samples, 0.04%) + + + +alloc_custom_gen (150,895,279 samples, 0.47%) + + + +caml_ba_alloc (1,627,836,790 samples, 5.09%) +caml_b.. + + +caml_memprof_track_custom (10,778,311 samples, 0.03%) + + + +caml_memprof_track_custom (89,985,118 samples, 0.28%) + + + +caml_empty_minor_heap (414,557,089 samples, 1.30%) + + + +caml_memprof_track_custom (4,447,011 samples, 0.01%) + + + +fiat_np256_divstep (13,885,614 samples, 0.04%) + + + +caml_ba_create (3,780,957 samples, 0.01%) + + + +point_add (4,462,759 samples, 0.01%) + + + +__hrtimer_run_queues (3,760,560 samples, 0.01%) + + + +Cstruct.create_919 (25,304,071 samples, 0.08%) + + + +tcache_put (40,964,713 samples, 0.13%) + + + +caml_ba_sub (5,701,678 samples, 0.02%) + + + +fiat_p256_addcarryx_u64 (1,205,067,491 samples, 3.77%) +fiat.. + + +fiat_np256_cmovznz_u64 (158,157,209 samples, 0.49%) + + + +memset@plt (6,172,668 samples, 0.02%) + + + +fiat_p256_add (170,783,605 samples, 0.53%) + + + +mc_p256_inv (722,844,990 samples, 2.26%) +m.. + + +caml_empty_minor_heap (6,216,038 samples, 0.02%) + + + +Cstruct.get_uint8_933 (3,177,002 samples, 0.01%) + + + +__gmpn_dcpi1_div_qr_n (7,651,992 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3487 (5,101,229 samples, 0.02%) + + + +memcpy@plt (24,739,475 samples, 0.08%) + + + +__GI___libc_free (3,085,626 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (10,808,091 samples, 0.03%) + + + +__GI___libc_free (76,873,142 samples, 0.24%) + + + +__gmpn_sbpi1_div_qr (5,101,296 samples, 0.02%) + + + +caml_program (28,885,422,701 samples, 90.25%) +caml_program + + +Mirage_crypto_ec.select_709 (16,440,894 samples, 0.05%) + + + +checked_request2size (11,989,541 samples, 0.04%) + + + +__GI___libc_free (198,991,280 samples, 0.62%) + + + +fiat_p256_selectznz (57,946,949 samples, 0.18%) + + + +_int_free (107,717,041 samples, 0.34%) + + + +__GI___libc_free (70,451,631 samples, 0.22%) + + + +memcpy@plt (25,409,387 samples, 0.08%) + + + +caml_gc_dispatch (4,407,119 samples, 0.01%) + + + +caml_alloc_string (3,823,575 samples, 0.01%) + + + +caml_ba_alloc (3,197,534 samples, 0.01%) + + + +_int_free (19,147,382 samples, 0.06%) + + + +mc_sha256_update (15,684,380 samples, 0.05%) + + + +_int_malloc (509,449,489 samples, 1.59%) + + + +caml_call_gc (8,770,562 samples, 0.03%) + + + +_int_malloc (559,710,720 samples, 1.75%) + + + +caml_empty_minor_heap (5,750,336 samples, 0.02%) + + + +main (28,886,741,538 samples, 90.26%) +main + + +caml_alloc_custom_mem (4,444,951 samples, 0.01%) + + + +caml_c_call (15,760,631 samples, 0.05%) + + + +_int_free (50,899,290 samples, 0.16%) + + + +mc_np256_inv (725,414,236 samples, 2.27%) +m.. + + +Stdlib.Bigarray.create_379 (7,654,925 samples, 0.02%) + + + +_int_free (28,593,143 samples, 0.09%) + + + +memcpy@plt (8,888,673 samples, 0.03%) + + + +caml_ba_alloc (4,444,949 samples, 0.01%) + + + +Mirage_crypto.Hash.finalize_545 (5,655,367 samples, 0.02%) + + + +__gmpz_probab_prime_p (8,252,278 samples, 0.03%) + + + +_int_free (109,896,346 samples, 0.34%) + + + +fiat_p256_subborrowx_u64 (162,421,951 samples, 0.51%) + + + +caml_alloc_small_dispatch (3,823,575 samples, 0.01%) + + + +caml_empty_minor_heap (6,209,405 samples, 0.02%) + + + +alloc_custom_gen (5,752,120 samples, 0.02%) + + + +_int_free (32,889,265 samples, 0.10%) + + + +fiat_p256_sub (399,199,231 samples, 1.25%) + + + +Cstruct.frametable (19,147,382 samples, 0.06%) + + + +sha256_do_chunk (3,155,179 samples, 0.01%) + + + +Mirage_crypto_ec.scalar_mult_932 (3,814,566 samples, 0.01%) + + + +caml_alloc_small_dispatch (203,886,624 samples, 0.64%) + + + +Cstruct.create_919 (8,953,633 samples, 0.03%) + + + +Cstruct.create_919 (3,668,637 samples, 0.01%) + + + +inversion (8,883,355 samples, 0.03%) + + + +sha256_do_chunk (6,364,869 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (10,678,544 samples, 0.03%) + + + +fiat_p256_square (8,747,719 samples, 0.03%) + + + +fiat_np256_addcarryx_u64 (246,388,390 samples, 0.77%) + + + +fiat_np256_addcarryx_u64 (4,470,511 samples, 0.01%) + + + +fiat_p384_square (5,080,351 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3596 (6,979,548 samples, 0.02%) + + + +sysvec_apic_timer_interrupt (3,760,560 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3749 (15,218,805 samples, 0.05%) + + + +__libc_start_main_impl (28,886,741,538 samples, 90.26%) +__libc_start_main_impl + + +__GI___libc_malloc (72,718,233 samples, 0.23%) + + + +__gmpn_tdiv_qr (4,480,887 samples, 0.01%) + + + +point_add (13,953,910 samples, 0.04%) + + + +Cstruct.create_unsafe_790 (3,820,865 samples, 0.01%) + + + +point_double (6,979,548 samples, 0.02%) + + + +sha256_do_chunk (23,950,156 samples, 0.07%) + + + +arena_for_chunk (3,179,938 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (8,280,247 samples, 0.03%) + + + +caml_ba_alloc (3,780,957 samples, 0.01%) + + + +Cstruct.append_1388 (3,809,391 samples, 0.01%) + + + +caml_alloc_custom_mem (3,146,758 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (4,372,119 samples, 0.01%) + + + +fiat_p256_cmovznz_u64 (102,099,744 samples, 0.32%) + + + +malloc@plt (7,537,876 samples, 0.02%) + + + +caml_ba_sub (6,341,598 samples, 0.02%) + + + +Cstruct.rev_1405 (4,366,244 samples, 0.01%) + + + +fiat_np256_to_montgomery (3,805,013 samples, 0.01%) + + + +_int_free (111,411,906 samples, 0.35%) + + + +Mirage_crypto_rng.Hmac_drbg.reseed_174 (166,531,525 samples, 0.52%) + + + +_mc_sha256_finalize (3,155,179 samples, 0.01%) + + + +arena_for_chunk (6,363,136 samples, 0.02%) + + + +__memcpy_avx_unaligned_erms (45,537,432 samples, 0.14%) + + + +caml_fill_bigstring (4,431,812 samples, 0.01%) + + + +__GI___libc_free (38,145,331 samples, 0.12%) + + + +Mirage_crypto.Hash.fun_1809 (18,958,865 samples, 0.06%) + + + +point_add (36,047,066 samples, 0.11%) + + + +mc_np256_to_montgomery (11,422,835 samples, 0.04%) + + + +Cstruct.to_bigarray_787 (840,733,321 samples, 2.63%) +Cs.. + + +mc_p256_select (206,545,201 samples, 0.65%) + + + +Mirage_crypto.Uncommon.xor_639 (5,038,683 samples, 0.02%) + + + +caml_apply3 (3,057,574 samples, 0.01%) + + + +free@plt (3,824,697 samples, 0.01%) + + + +Mirage_crypto_ec.from_be_cstruct_1016 (18,918,976 samples, 0.06%) + + + +tick_sched_handle (3,608,774 samples, 0.01%) + + + +_int_free (22,879,432 samples, 0.07%) + + + +fiat_p256_add (82,810,197 samples, 0.26%) + + + +fiat_p256_cmovznz_u64 (46,061,914 samples, 0.14%) + + + +caml_ba_alloc (6,972,762 samples, 0.02%) + + + +_int_free (3,186,965 samples, 0.01%) + + + +caml_ba_create (6,966,111 samples, 0.02%) + + + +Cstruct.create_919 (10,808,091 samples, 0.03%) + + + +caml_ba_alloc (859,680,219 samples, 2.69%) +ca.. + + +Mirage_crypto_ec.scalar_mult_932 (52,688,772 samples, 0.16%) + + + +alloc_custom_gen (595,755,129 samples, 1.86%) +a.. + + +Stdlib.Bigarray.create_379 (33,366,201 samples, 0.10%) + + + +alloc_custom_gen (609,589,116 samples, 1.90%) +a.. + + +alloc_custom_gen (67,291,520 samples, 0.21%) + + + +Mirage_crypto.Uncommon.rpad_664 (5,712,422 samples, 0.02%) + + + +Cstruct.create_unsafe_790 (4,447,011 samples, 0.01%) + + + +mc_p384_point_add (4,462,759 samples, 0.01%) + + + +tick_sched_timer (4,248,545 samples, 0.01%) + + + +mc_p256_sqr (3,829,818 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (2,230,904,656 samples, 6.97%) +Cstruct.c.. + + +caml_ba_alloc (3,770,238 samples, 0.01%) + + + +__gmpn_fib2m (4,451,740 samples, 0.01%) + + + +fiat_p256_mulx_u64 (457,905,557 samples, 1.43%) + + + +fiat_p521_addcarryx_u64 (5,055,372 samples, 0.02%) + + + +caml_alloc_small (3,160,360 samples, 0.01%) + + + +memcpy@plt (9,433,468 samples, 0.03%) + + + +Cstruct.create_unsafe_790 (1,062,249,323 samples, 3.32%) +Cst.. + + +caml_start_program (28,885,422,701 samples, 90.25%) +caml_start_program + + +caml_apply3 (4,412,061 samples, 0.01%) + + + +alloc_custom_gen (3,146,758 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1807 (15,684,380 samples, 0.05%) + + + +fiat_p256_subborrowx_u64 (504,981,434 samples, 1.58%) + + + +fiat_p521_addcarryx_u64 (7,627,904 samples, 0.02%) + + + +_mc_sha256_update (23,950,156 samples, 0.07%) + + + +update_process_times (2,971,152 samples, 0.01%) + + + +caml_ba_update_proxy (10,693,079 samples, 0.03%) + + + +caml_ba_finalize (76,250,832 samples, 0.24%) + + + +Cstruct.append_1388 (5,060,694 samples, 0.02%) + + + +Stdlib.Bigarray.create_379 (3,668,637 samples, 0.01%) + + + +Mirage_crypto.Hash.hmaci_648 (25,694,334 samples, 0.08%) + + + +Mirage_crypto_rng.Hmac_drbg.go_240 (29,457,534 samples, 0.09%) + + + +caml_alloc_custom_mem (3,197,253 samples, 0.01%) + + + +caml_alloc_small_dispatch (189,546,881 samples, 0.59%) + + + +_int_free (119,346,214 samples, 0.37%) + + + +sysvec_apic_timer_interrupt (6,133,224 samples, 0.02%) + + + +caml_alloc_small (195,833,549 samples, 0.61%) + + + +entry_SYSCALL_64_after_hwframe (41,853,163 samples, 0.13%) + + + +fiat_p256_mulx_u64 (326,106,685 samples, 1.02%) + + + +Mirage_crypto_ec.add_815 (5,110,276 samples, 0.02%) + + + +__memcpy_avx_unaligned_erms (4,450,384 samples, 0.01%) + + + +caml_ba_create (3,807,258 samples, 0.01%) + + + +caml_sys_time_unboxed (64,691,404 samples, 0.20%) + + + +caml_ba_finalize (288,080,609 samples, 0.90%) + + + +__memcpy_avx_unaligned_erms (27,054,175 samples, 0.08%) + + + +Cstruct.create_919 (1,082,442,537 samples, 3.38%) +Cst.. + + +caml_gc_dispatch (114,971,930 samples, 0.36%) + + + +__sysvec_apic_timer_interrupt (3,760,560 samples, 0.01%) + + + +Mirage_crypto_ec.sign_1120 (193,002,462 samples, 0.60%) + + + +alloc_custom_gen (616,503,215 samples, 1.93%) +a.. + + +sha256_do_chunk (17,660,008 samples, 0.06%) + + + +fiat_p256_divstep (15,840,992 samples, 0.05%) + + + +Mirage_crypto.Hash.fun_1807 (20,085,810 samples, 0.06%) + + + +__GI___libc_malloc (637,756,227 samples, 1.99%) +_.. + + +__GI___libc_free (43,827,974 samples, 0.14%) + + + +Mirage_crypto_ec.is_in_range_922 (18,888,804 samples, 0.06%) + + + +caml_call_gc (128,825,989 samples, 0.40%) + + + +Mirage_crypto_ec.do_sign_1128 (26,046,695,516 samples, 81.38%) +Mirage_crypto_ec.do_sign_1128 + + +getrusage (16,497,050 samples, 0.05%) + + + +_int_malloc (572,234,889 samples, 1.79%) + + + +Mirage_crypto_ec.select_826 (4,454,090,821 samples, 13.92%) +Mirage_crypto_ec.sele.. + + +caml_empty_minor_heap (187,631,333 samples, 0.59%) + + + +caml_ba_create (20,218,893 samples, 0.06%) + + + +Mirage_crypto.Hash.finalize_545 (16,484,743 samples, 0.05%) + + + +caml_ba_finalize (88,183,630 samples, 0.28%) + + + +Dune.exe.Speed.count_436 (26,246,678,635 samples, 82.01%) +Dune.exe.Speed.count_436 + + +speed.exe (32,004,550,576 samples, 100.00%) +speed.exe + + +Mirage_crypto.Hash.fun_1809 (18,925,107 samples, 0.06%) + + + +__GI___libc_malloc (3,800,414 samples, 0.01%) + + + +Stdlib.Bigarray.create_379 (6,966,111 samples, 0.02%) + + + +fiat_p256_square (1,763,631,747 samples, 5.51%) +fiat_p2.. + + +fe_cmovznz (57,946,949 samples, 0.18%) + + + +fiat_p256_addcarryx_u64 (383,913,105 samples, 1.20%) + + + +caml_fill_bigstring (41,660,896 samples, 0.13%) + + + +caml_alloc_small_dispatch (377,386,972 samples, 1.18%) + + + +caml_alloc_custom_mem (8,209,446 samples, 0.03%) + + + +Mirage_crypto.Hash.fun_1809 (4,400,412 samples, 0.01%) + + + +caml_gc_dispatch (415,191,784 samples, 1.30%) + + + +tick_sched_timer (4,451,710 samples, 0.01%) + + + +caml_ba_create (8,953,633 samples, 0.03%) + + + +alloc_custom_gen (3,188,179 samples, 0.01%) + + + +caml_alloc_small_dispatch (8,770,562 samples, 0.03%) + + + +fiat_p521_square (5,063,734 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3441 (12,603,553 samples, 0.04%) + + + +caml_ba_sub (3,721,575 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3751 (13,953,910 samples, 0.04%) + + + +alloc_custom_gen (631,192,227 samples, 1.97%) +a.. + + +__sysvec_apic_timer_interrupt (4,451,710 samples, 0.01%) + + + +caml_memprof_track_custom (25,189,975 samples, 0.08%) + + + +caml_gc_dispatch (5,750,336 samples, 0.02%) + + + +Stdlib.List.iter_261 (26,250,471,420 samples, 82.02%) +Stdlib.List.iter_261 + + +mc_sha256_update (6,364,869 samples, 0.02%) + + + +Mirage_crypto.Hash.finalize_545 (24,681,866 samples, 0.08%) + + + +Cstruct.to_bigarray_787 (3,820,558 samples, 0.01%) + + + +alloc_custom_gen (3,173,938 samples, 0.01%) + + + +Cstruct.get_uint8_933 (11,766,558 samples, 0.04%) + + + +caml_empty_minor_heap (4,487,559 samples, 0.01%) + + + +fiat_np256_to_montgomery (9,516,656 samples, 0.03%) + + + +__do_sys_getrusage (16,497,050 samples, 0.05%) + + + +__memcpy_avx_unaligned_erms (88,226,794 samples, 0.28%) + + + +Mirage_crypto_ec.secret_of_cs_962 (54,591,888 samples, 0.17%) + + + +point_add (6,394,928,418 samples, 19.98%) +point_add + + +Stdlib.List.iter_261 (26,250,471,420 samples, 82.02%) +Stdlib.List.iter_261 + + +Cstruct.to_bigarray_787 (6,852,003 samples, 0.02%) + + + +Stdlib.Bigarray.create_379 (3,804,052 samples, 0.01%) + + + +_mc_sha256_update (3,155,179 samples, 0.01%) + + + +fiat_p256_cmovznz_u64 (54,107,079 samples, 0.17%) + + + +Stdlib.Bigarray.create_379 (1,801,962,660 samples, 5.63%) +Stdlib... + + +arena_for_chunk (4,463,608 samples, 0.01%) + + + +__libc_start_call_main (28,886,741,538 samples, 90.26%) +__libc_start_call_main + + +Cstruct.create_919 (8,280,247 samples, 0.03%) + + + +mc_np256_inv (8,883,355 samples, 0.03%) + + + +caml_ba_alloc (6,966,111 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (3,170,051 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1809 (3,155,179 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1807 (7,028,208 samples, 0.02%) + + + +hrtimer_interrupt (3,760,560 samples, 0.01%) + + + +Mirage_crypto_ec.from_be_cstruct_1016 (11,946,943 samples, 0.04%) + + + +Mirage_crypto.Uncommon.rpad_664 (10,816,533 samples, 0.03%) + + + +caml_gc_dispatch (6,209,405 samples, 0.02%) + + + +fiat_p256_addcarryx_u64 (119,072,056 samples, 0.37%) + + + +do_syscall_64 (2,876,398 samples, 0.01%) + + + +_dl_relocate_object (5,206,101 samples, 0.02%) + + + +sha256_do_chunk (13,933,005 samples, 0.04%) + + + +Cstruct.to_bigarray_787 (1,698,175,672 samples, 5.31%) +Cstruc.. + + +caml_ba_sub (3,820,558 samples, 0.01%) + + + +_mc_sha256_finalize (4,400,412 samples, 0.01%) + + + +caml_ba_alloc (3,785,596 samples, 0.01%) + + + +mc_sha256_finalize (15,204,742 samples, 0.05%) + + + +mc_sha256_finalize (4,400,412 samples, 0.01%) + + + +malloc@plt (4,394,050 samples, 0.01%) + + + +Dune.exe.Speed.time_143 (26,241,615,541 samples, 81.99%) +Dune.exe.Speed.time_143 + + +_int_free (50,774,408 samples, 0.16%) + + + +free@plt (5,091,882 samples, 0.02%) + + + +Cstruct.to_bigarray_787 (6,303,345 samples, 0.02%) + + + +caml_empty_minor_heap (51,649,754 samples, 0.16%) + + + +Cstruct.create_919 (3,817,576 samples, 0.01%) + + + +caml_alloc_small_dispatch (51,649,754 samples, 0.16%) + + + +caml_check_urgent_gc (5,064,572 samples, 0.02%) + + + +checked_request2size (3,166,532 samples, 0.01%) + + + +__gmpz_tdiv_r (5,742,508 samples, 0.02%) + + + +caml_ba_sub (91,556,826 samples, 0.29%) + + + +Mirage_crypto_ec.double_811 (11,366,090,740 samples, 35.51%) +Mirage_crypto_ec.double_811 + + +caml_call_gc (118,127,611 samples, 0.37%) + + + +caml_alloc_custom_mem (725,277,730 samples, 2.27%) +c.. + + +tick_sched_handle (3,119,205 samples, 0.01%) + + + +caml_alloc_small_dispatch (387,950,425 samples, 1.21%) + + + +_mc_sha256_update (4,400,412 samples, 0.01%) + + + +fiat_p256_cmovznz_u64 (120,215,608 samples, 0.38%) + + + +caml_ba_finalize (259,190,933 samples, 0.81%) + + + +__GI___libc_free (75,585,405 samples, 0.24%) + + + +caml_empty_minor_heap (368,657,519 samples, 1.15%) + + + +caml_gc_dispatch (4,434,436 samples, 0.01%) + + + +__hrtimer_run_queues (4,451,710 samples, 0.01%) + + + +__GI___libc_free (25,489,803 samples, 0.08%) + + + +caml_ba_create (3,668,637 samples, 0.01%) + + + +_mc_sha256_finalize (15,204,742 samples, 0.05%) + + + +entry_SYSCALL_64 (6,997,664 samples, 0.02%) + + + +__GI___libc_malloc (9,498,764 samples, 0.03%) + + + +__GI___libc_malloc (584,164,102 samples, 1.83%) +_.. + + +Cstruct.create_unsafe_790 (5,075,200 samples, 0.02%) + + + +_int_free (78,617,108 samples, 0.25%) + + + +sysvec_apic_timer_interrupt (3,821,445 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (10,175,553 samples, 0.03%) + + + +Mirage_crypto.Hash.hmaci_648 (129,815,574 samples, 0.41%) + + + +fiat_p256_subborrowx_u64 (244,451,450 samples, 0.76%) + + + +caml_call_gc (6,368,987 samples, 0.02%) + + + +Mirage_crypto_ec.is_in_range_922 (6,365,902 samples, 0.02%) + + + +Cstruct.create_919 (2,277,606,996 samples, 7.12%) +Cstruct.c.. + + +Cstruct.to_bigarray_787 (8,793,323 samples, 0.03%) + + + +elf_machine_rela_relative (3,790,995 samples, 0.01%) + + + +arena_for_chunk (4,464,042 samples, 0.01%) + + + +sha256_do_chunk (15,047,646 samples, 0.05%) + + + +__GI___libc_free (8,303,958 samples, 0.03%) + + + +Stdlib.Bigarray.create_379 (1,764,001,203 samples, 5.51%) +Stdlib... + + +fiat_p256_addcarryx_u64 (70,857,462 samples, 0.22%) + + + +caml_gc_dispatch (6,216,038 samples, 0.02%) + + + +fiat_p521_square (8,899,336 samples, 0.03%) + + + +free@plt (6,364,093 samples, 0.02%) + + + +Stdlib.Bytes.copy_105 (5,090,479 samples, 0.02%) + + + +_int_malloc (9,357,649 samples, 0.03%) + + + +fiat_p256_add (11,905,080 samples, 0.04%) + + + +Dune.exe.Speed.runv_1309 (2,531,788,015 samples, 7.91%) +Dune.exe.Sp.. + + +mc_p384_point_double (6,979,548 samples, 0.02%) + + + +fiat_p256_addcarryx_u64 (1,376,843,589 samples, 4.30%) +fiat_.. + + +fiat_p256_add (1,151,310,421 samples, 3.60%) +fia.. + + +_int_free (51,657,314 samples, 0.16%) + + + +_int_malloc (272,301,393 samples, 0.85%) + + + +ml_z_probab_prime (8,252,278 samples, 0.03%) + + + +Stdlib.Bigarray.create_379 (8,953,633 samples, 0.03%) + + + +mark_slice_darken.constprop.0 (3,151,734 samples, 0.01%) + + + +alloc_custom_gen (3,197,253 samples, 0.01%) + + + +mc_np256_mul (3,758,416 samples, 0.01%) + + + +caml_alloc_small_dispatch (395,421,318 samples, 1.24%) + + + +caml_c_call (3,771,281 samples, 0.01%) + + + +inversion (13,940,932 samples, 0.04%) + + + +free@plt (5,753,296 samples, 0.02%) + + + +alloc_custom_gen (3,159,479 samples, 0.01%) + + + +mc_sha256_finalize (18,925,107 samples, 0.06%) + + + +caml_empty_minor_heap (114,971,930 samples, 0.36%) + + + +_int_malloc (8,719,687 samples, 0.03%) + + + +Stdlib.Bigarray.create_379 (4,420,441 samples, 0.01%) + + + +caml_memprof_track_custom (10,127,251 samples, 0.03%) + + + +[[heap]] (354,879,097 samples, 1.11%) + + + +alloc_custom_gen (3,801,402 samples, 0.01%) + + + +_int_free (43,253,163 samples, 0.14%) + + + +Cstruct.create_unsafe_790 (3,668,637 samples, 0.01%) + + + +fiat_p256_divstep (715,236,296 samples, 2.23%) +f.. + + +__gmpz_stronglucas (7,008,158 samples, 0.02%) + + + +_int_malloc (493,761,809 samples, 1.54%) + + + +arena_for_chunk (5,088,177 samples, 0.02%) + + + +mc_sha256_update (7,028,208 samples, 0.02%) + + + +Mirage_crypto_ec.frametable (9,521,368 samples, 0.03%) + + + +fiat_p521_mul (8,250,208 samples, 0.03%) + + + +__gmpz_millerrabin (18,485,729 samples, 0.06%) + + + +caml_empty_minor_heap (181,970,605 samples, 0.57%) + + + +tcache_put (15,202,861 samples, 0.05%) + + + +__GI___libc_free (97,644,232 samples, 0.31%) + + + +_dl_start_final (6,027,808 samples, 0.02%) + + + +Mirage_crypto.Hash.fun_1742 (6,056,180 samples, 0.02%) + + + +fiat_p256_mul (3,923,470,209 samples, 12.26%) +fiat_p256_mul + + +asm_sysvec_apic_timer_interrupt (6,133,224 samples, 0.02%) + + + +Mirage_crypto_pk.Rsa.valid_prime_447 (8,252,278 samples, 0.03%) + + + +Cstruct.to_bigarray_787 (17,735,843 samples, 0.06%) + + + +mc_sha256_update (6,056,180 samples, 0.02%) + + + +caml_ba_finalize (123,387,070 samples, 0.39%) + + + +caml_ba_create (3,800,379 samples, 0.01%) + + + +__gmpz_tdiv_r (5,116,832 samples, 0.02%) + + + +ror32 (3,823,274 samples, 0.01%) + + + +checked_request2size (11,324,523 samples, 0.04%) + + + +caml_ba_alloc (51,040,356 samples, 0.16%) + + + +caml_ba_create (6,972,762 samples, 0.02%) + + + +__memset_avx2_unaligned_erms (22,180,244 samples, 0.07%) + + + +Mirage_crypto.Hash.fun_1742 (21,908,528 samples, 0.07%) + + + +fiat_p256_subborrowx_u64 (69,028,190 samples, 0.22%) + + + +Mirage_crypto_ec.go_1085 (133,745,253 samples, 0.42%) + + + +fiat_np256_value_barrier_u64 (3,715,671 samples, 0.01%) + + + +__gmpn_sbpi1_div_qr (4,480,887 samples, 0.01%) + + + +_mc_sha256_update (6,364,869 samples, 0.02%) + + + +Mirage_crypto_pk.Z_extra.pseudoprime_251 (7,638,867 samples, 0.02%) + + + +_int_free (29,006,412 samples, 0.09%) + + + +caml_ba_finalize (295,073,820 samples, 0.92%) + + + +Cstruct.concat_1395 (6,347,858 samples, 0.02%) + + + +fiat_p256_selectznz (91,770,795 samples, 0.29%) + + + +Mirage_crypto_ec.double_811 (10,766,907 samples, 0.03%) + + + +Cstruct.create_unsafe_790 (4,420,441 samples, 0.01%) + + + +arena_for_chunk (5,740,187 samples, 0.02%) + + + +__memcpy_avx_unaligned_erms (63,408,037 samples, 0.20%) + + + +caml_fill_bigstring (37,866,502 samples, 0.12%) + + + +fiat_p256_square (30,169,063 samples, 0.09%) + + + +caml_alloc_small (496,170,212 samples, 1.55%) + + + +fe_nz (5,699,290 samples, 0.02%) + + + +Mirage_crypto_ec.select_709 (16,957,032 samples, 0.05%) + + + +caml_gc_dispatch (126,931,342 samples, 0.40%) + + + +Mirage_crypto_pk.Dh.entry (3,891,166 samples, 0.01%) + + + +caml_check_urgent_gc (6,216,038 samples, 0.02%) + + + +Cstruct.to_bigarray_787 (3,718,234 samples, 0.01%) + + + +malloc@plt (7,582,993 samples, 0.02%) + + + +caml_ba_sub (6,852,003 samples, 0.02%) + + + +__GI___libc_free (3,199,727 samples, 0.01%) + + + +__GI___libc_free (87,768,400 samples, 0.27%) + + + +caml_gc_dispatch (368,657,519 samples, 1.15%) + + + +tcache_get (13,245,276 samples, 0.04%) + + + +Eqaf_bigstring.compare_be_434 (7,504,369 samples, 0.02%) + + + +caml_ba_finalize (37,615,917 samples, 0.12%) + + + +caml_alloc_custom_mem (5,102,997 samples, 0.02%) + + + +caml_gc_dispatch (391,628,179 samples, 1.22%) + + + +_int_malloc (278,833,292 samples, 0.87%) + + + +Mirage_crypto_ec.fun_3439 (722,844,990 samples, 2.26%) +M.. + + +__GI___libc_free (207,345,533 samples, 0.65%) + + + +caml_ba_update_proxy (643,723,661 samples, 2.01%) +c.. + + +handle_pte_fault (3,066,333 samples, 0.01%) + + + +caml_oldify_local_roots (3,821,821 samples, 0.01%) + + + +arena_for_chunk (3,195,221 samples, 0.01%) + + + +caml_alloc_small (4,487,559 samples, 0.01%) + + + +fiat_p256_square (54,003,435 samples, 0.17%) + + + +__GI___libc_free (24,777,334 samples, 0.08%) + + + +__GI___libc_malloc (6,337,483 samples, 0.02%) + + + +fiat_p256_subborrowx_u64 (174,823,508 samples, 0.55%) + + + +caml_ba_create (7,626,209 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3501 (3,805,013 samples, 0.01%) + + + +__GI___libc_malloc (319,755,029 samples, 1.00%) + + + +caml_ba_alloc (177,155,751 samples, 0.55%) + + + +mc_p256_select (4,421,480 samples, 0.01%) + + + +alloc_custom_gen (4,464,862 samples, 0.01%) + + + +tcache_put (42,507,389 samples, 0.13%) + + + +Mirage_crypto_ec.at_infinity_757 (10,679,424 samples, 0.03%) + + + +Stdlib.Bigarray.create_379 (4,451,912 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3433 (3,829,818 samples, 0.01%) + + + +caml_empty_minor_heap (4,430,928 samples, 0.01%) + + + +Mirage_crypto.Hash.hmaci_648 (61,941,722 samples, 0.19%) + + + +all (32,004,581,106 samples, 100%) + + + +checked_request2size (5,695,580 samples, 0.02%) + + + +fiat_p256_mulx_u64 (875,072,108 samples, 2.73%) +fi.. + + +Mirage_crypto_ec.of_cstruct_925 (10,084,024 samples, 0.03%) + + + +Stdlib.Bytes.copy_105 (5,041,599 samples, 0.02%) + + + +__gmpn_addmul_2 (49,074,007 samples, 0.15%) + + + +Mirage_crypto_ec.fun_3487 (3,758,416 samples, 0.01%) + + + +[anon] (698,575,058 samples, 2.18%) +[.. + + +Cstruct.to_bigarray_787 (12,496,422 samples, 0.04%) + + + +fiat_p521_addcarryx_u64 (4,428,393 samples, 0.01%) + + + +Cstruct.create_919 (5,075,200 samples, 0.02%) + + + +malloc@plt (3,189,088 samples, 0.01%) + + + +caml_ba_finalize (3,199,727 samples, 0.01%) + + + +caml_ba_sub (1,681,286,040 samples, 5.25%) +caml_b.. + + +hrtimer_interrupt (5,505,601 samples, 0.02%) + + + +caml_call_gc (51,649,754 samples, 0.16%) + + + +_int_free (108,647,750 samples, 0.34%) + + + +caml_ba_alloc (8,314,607 samples, 0.03%) + + + +__gmpn_tdiv_qr (8,924,422 samples, 0.03%) + + + + \ No newline at end of file diff --git a/images/trace-string-770.svg b/images/trace-string-770.svg new file mode 100644 index 0000000..f8a78c5 --- /dev/null +++ b/images/trace-string-770.svg @@ -0,0 +1,2709 @@ + + + + + + + + + + + + + + +Flame Graph + +Reset Zoom +Search +ic + + + +Mirage_crypto_ec.fun_3773 (3,174,539 samples, 0.01%) + + + +Mirage_crypto_ec.add_845 (2,563,866 samples, 0.01%) + + + +Mirage_crypto_ec.secret_of_cs_992 (62,283,510 samples, 0.22%) + + + +Mirage_crypto_ec.inv_1096 (1,149,196,954 samples, 4.01%) +Mira.. + + +Cstruct.create_unsafe_790 (8,269,203 samples, 0.03%) + + + +caml_ba_alloc (3,109,846 samples, 0.01%) + + + +fiat_p521_addcarryx_u64 (3,163,862 samples, 0.01%) + + + +_dl_relocate_object (5,162,178 samples, 0.02%) + + + +Mirage_crypto.Uncommon.xor_639 (5,735,955 samples, 0.02%) + + + +caml_ba_create (3,081,485 samples, 0.01%) + + + +__gmpn_sbpi1_div_qr (3,811,216 samples, 0.01%) + + + +fiat_np256_addcarryx_u64 (2,523,844 samples, 0.01%) + + + +Mirage_crypto_ec.to_affine_raw_794 (3,036,716 samples, 0.01%) + + + +Mirage_crypto.Uncommon.rpad_664 (3,081,485 samples, 0.01%) + + + +_int_malloc (3,778,912 samples, 0.01%) + + + +fiat_p256_addcarryx_u64 (371,668,960 samples, 1.30%) + + + +mc_np256_inv (10,835,812 samples, 0.04%) + + + +mc_p256_point_double (7,605,956 samples, 0.03%) + + + +_mc_sha256_update (14,637,402 samples, 0.05%) + + + +Mirage_crypto.Hash.fun_1742 (15,494,806 samples, 0.05%) + + + +Mirage_crypto.Hash.feedi_558 (78,570,114 samples, 0.27%) + + + +caml_oldify_local_roots (3,175,256 samples, 0.01%) + + + +Stdlib.Bigarray.create_379 (8,269,203 samples, 0.03%) + + + +_mc_sha256_update (15,288,439 samples, 0.05%) + + + +_mc_sha256_update (15,494,806 samples, 0.05%) + + + +caml_alloc_small_dispatch (15,234,025 samples, 0.05%) + + + +Mirage_crypto_ec.rev_string_292 (2,447,822 samples, 0.01%) + + + +fiat_p384_square (2,764,649 samples, 0.01%) + + + +point_add (12,061,825 samples, 0.04%) + + + +Mirage_crypto_ec.fun_3773 (2,523,844 samples, 0.01%) + + + +caml_alloc_string (79,394,305 samples, 0.28%) + + + +caml_alloc_custom_mem (3,821,544 samples, 0.01%) + + + +mark_slice (2,550,031 samples, 0.01%) + + + +__lock_task_sighand (5,081,858 samples, 0.02%) + + + +Mirage_crypto.Hash.fun_1737 (8,252,353 samples, 0.03%) + + + +mc_np256_to_montgomery (3,174,539 samples, 0.01%) + + + +sysvec_apic_timer_interrupt (5,110,529 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3716 (19,352,352 samples, 0.07%) + + + +Mirage_crypto.Hash.finalize_545 (37,303,553 samples, 0.13%) + + + +Mirage_crypto_ec.fun_3564 (3,728,536 samples, 0.01%) + + + +syscall_exit_to_user_mode (21,519,976 samples, 0.08%) + + + +fiat_p521_mul (10,793,592 samples, 0.04%) + + + +fiat_np256_to_montgomery (2,523,844 samples, 0.01%) + + + +fiat_p256_addcarryx_u64 (115,164,737 samples, 0.40%) + + + +Mirage_crypto_ec.scalar_mult_956 (2,499,314 samples, 0.01%) + + + +fiat_np256_cmovznz_u64 (239,843,002 samples, 0.84%) + + + +Mirage_crypto_ec.select_855 (2,557,815 samples, 0.01%) + + + +__gmpn_sbpi1_div_qr (11,486,695 samples, 0.04%) + + + +__do_sys_getrusage (22,079,974 samples, 0.08%) + + + +caml_gc_dispatch (2,434,916 samples, 0.01%) + + + +caml_ba_create (2,553,949 samples, 0.01%) + + + +fiat_p256_addcarryx_u64 (3,606,552,239 samples, 12.57%) +fiat_p256_addcarry.. + + +_mc_sha256_update (2,558,404 samples, 0.01%) + + + +fiat_p256_mul (3,838,582 samples, 0.01%) + + + +Mirage_crypto_ec.select_686 (16,158,118 samples, 0.06%) + + + +Stdlib.Bytes.make_93 (10,778,610 samples, 0.04%) + + + +Mirage_crypto_ec.mul_1086 (4,972,643 samples, 0.02%) + + + +mc_sha256_update (29,138,276 samples, 0.10%) + + + +Mirage_crypto_ec.mul_1086 (4,473,419 samples, 0.02%) + + + +_mc_sha256_update (8,924,929 samples, 0.03%) + + + +mc_np256_from_montgomery (2,554,371 samples, 0.01%) + + + +Mirage_crypto_ec.of_octets_949 (6,274,194 samples, 0.02%) + + + +caml_c_call (21,359,050 samples, 0.07%) + + + +Mirage_crypto_ec.to_affine_raw_794 (1,091,129,534 samples, 3.80%) +Mira.. + + +Mirage_crypto_ec.scalar_mult_956 (21,863,690,120 samples, 76.23%) +Mirage_crypto_ec.scalar_mult_956 + + +_int_free (2,551,515 samples, 0.01%) + + + +_mc_sha256_finalize (19,742,601 samples, 0.07%) + + + +caml_major_collection_slice (2,550,031 samples, 0.01%) + + + +Dune.exe.Speed.runv_1309 (2,529,658,813 samples, 8.82%) +Dune.exe.Spe.. + + +mc_sha256_update (7,003,862 samples, 0.02%) + + + +_mc_sha256_finalize (2,558,404 samples, 0.01%) + + + +Mirage_crypto_pk.Z_extra.pseudoprime_251 (7,621,886 samples, 0.03%) + + + +fiat_p256_square (2,663,618,552 samples, 9.29%) +fiat_p256_squ.. + + +Mirage_crypto_ec.g_octets_1203 (181,827,993 samples, 0.63%) + + + +fiat_p256_divstep (22,869,539 samples, 0.08%) + + + +Mirage_crypto.Hash.fun_1737 (16,564,892 samples, 0.06%) + + + +fiat_p256_sub (656,602,397 samples, 2.29%) +f.. + + +Mirage_crypto.Hash.finalize_545 (33,073,560 samples, 0.12%) + + + +caml_c_call (56,391,514 samples, 0.20%) + + + +caml_ba_create (4,436,806 samples, 0.02%) + + + +_mc_sha256_update (7,003,862 samples, 0.02%) + + + +Stdlib.Bigarray.create_379 (3,187,320 samples, 0.01%) + + + +Mirage_crypto_ec.add_point_714 (4,466,965 samples, 0.02%) + + + +Cstruct.create_unsafe_790 (11,446,678 samples, 0.04%) + + + +caml_ba_alloc (8,257,713 samples, 0.03%) + + + +__gmpz_probab_prime_p (6,375,214 samples, 0.02%) + + + +Mirage_crypto_rng.Hmac_drbg.generate_184 (126,201,603 samples, 0.44%) + + + +fiat_p256_nonzero (5,732,736 samples, 0.02%) + + + +_mc_sha256_finalize (29,244,042 samples, 0.10%) + + + +Mirage_crypto_ec.fun_3251 (3,172,601 samples, 0.01%) + + + +_dl_start_final (6,084,015 samples, 0.02%) + + + +alloc_custom_gen (3,183,276 samples, 0.01%) + + + +caml_ba_create (2,552,660 samples, 0.01%) + + + +ror32 (7,022,899 samples, 0.02%) + + + +__hrtimer_run_queues (2,561,706 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1742 (29,138,276 samples, 0.10%) + + + +point_double (15,219,841 samples, 0.05%) + + + +fiat_p256_add (265,749,306 samples, 0.93%) + + + +Stdlib.Bigarray.create_379 (3,180,757 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1809 (19,742,601 samples, 0.07%) + + + +mc_sha256_finalize (15,919,767 samples, 0.06%) + + + +Mirage_crypto.Hash.feedi_558 (33,959,653 samples, 0.12%) + + + +Mirage_crypto_pk.Z_extra.pseudoprime_251 (6,375,214 samples, 0.02%) + + + +Dune.exe.Speed.time_143 (24,490,035,133 samples, 85.39%) +Dune.exe.Speed.time_143 + + +_mc_sha256_update (30,356,717 samples, 0.11%) + + + +ml_z_probab_prime (6,375,214 samples, 0.02%) + + + +mc_sha256_update (14,637,402 samples, 0.05%) + + + +Mirage_crypto_ec.from_be_octets_1078 (5,076,431 samples, 0.02%) + + + +Cstruct.create_919 (3,193,502 samples, 0.01%) + + + +fiat_np256_to_montgomery (10,843,576 samples, 0.04%) + + + +caml_alloc_small_dispatch (3,835,221 samples, 0.01%) + + + +Mirage_crypto.Hash.feedi_558 (17,807,448 samples, 0.06%) + + + +_dl_sysdep_start (6,084,015 samples, 0.02%) + + + +__gmpn_redc_1 (34,288,256 samples, 0.12%) + + + +Stdlib.Bigarray.create_379 (2,553,949 samples, 0.01%) + + + +ror32 (10,202,680 samples, 0.04%) + + + +Cstruct.create_919 (2,552,341 samples, 0.01%) + + + +mc_p256_mul (7,602,052 samples, 0.03%) + + + +Mirage_crypto.Hash.fun_1742 (7,003,862 samples, 0.02%) + + + +Cstruct.create_919 (3,165,453 samples, 0.01%) + + + +ror32 (2,549,728 samples, 0.01%) + + + +mc_np256_to_montgomery (2,523,844 samples, 0.01%) + + + +caml_apply4 (17,857,355 samples, 0.06%) + + + +__libc_start_main_impl (27,138,147,338 samples, 94.62%) +__libc_start_main_impl + + +__gmpn_mul_basecase (31,836,041 samples, 0.11%) + + + +mc_p256_from_montgomery (4,380,461 samples, 0.02%) + + + +sha256_do_chunk (12,735,338 samples, 0.04%) + + + +__gmpn_strongfibo (14,670,893 samples, 0.05%) + + + +fiat_p256_square (19,347,898 samples, 0.07%) + + + +asm_exc_page_fault (2,994,424 samples, 0.01%) + + + +point_double (3,728,536 samples, 0.01%) + + + +mc_p521_point_add (12,061,825 samples, 0.04%) + + + +caml_ba_create (3,196,331 samples, 0.01%) + + + +__hrtimer_run_queues (3,836,372 samples, 0.01%) + + + +fiat_np256_subborrowx_u64 (359,845,931 samples, 1.25%) + + + +inverse (1,071,489,326 samples, 3.74%) +inve.. + + +Mirage_crypto_ec.fun_3872 (8,220,000 samples, 0.03%) + + + +Mirage_crypto_ec.is_in_range_946 (7,584,951 samples, 0.03%) + + + +fiat_p256_value_barrier_u64 (8,305,940 samples, 0.03%) + + + +fiat_p256_addcarryx_u64 (167,000,494 samples, 0.58%) + + + +entry_SYSCALL_64_safe_stack (2,756,010 samples, 0.01%) + + + +fiat_np256_mul (4,429,205 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (24,650,662 samples, 0.09%) + + + +__gmpz_millerrabin (5,746,100 samples, 0.02%) + + + +caml_alloc_small_dispatch (3,075,953 samples, 0.01%) + + + +sha256_do_chunk (27,970,392 samples, 0.10%) + + + +mc_sha256_finalize (30,972,386 samples, 0.11%) + + + +Mirage_crypto_ec.fun_4026 (15,219,841 samples, 0.05%) + + + +caml_c_call (4,919,146 samples, 0.02%) + + + +__x64_sys_getrusage (22,672,483 samples, 0.08%) + + + +__gmpn_tdiv_qr (3,830,540 samples, 0.01%) + + + +fiat_p256_subborrowx_u64 (333,547,181 samples, 1.16%) + + + +fiat_p256_mulx_u64 (565,891,689 samples, 1.97%) +f.. + + +thread_group_cputime_adjusted (9,537,406 samples, 0.03%) + + + +caml_apply3 (7,654,196 samples, 0.03%) + + + +caml_gc_dispatch (5,521,835 samples, 0.02%) + + + +exc_page_fault (2,994,424 samples, 0.01%) + + + +fiat_p256_add (93,451,277 samples, 0.33%) + + + +ror32 (5,747,372 samples, 0.02%) + + + +Stdlib.List.iter_261 (24,495,047,907 samples, 85.40%) +Stdlib.List.iter_261 + + +fiat_p256_cmovznz_u64 (254,068,463 samples, 0.89%) + + + +fiat_p256_sub (629,570,514 samples, 2.20%) +f.. + + +inverse (10,835,812 samples, 0.04%) + + + +Mirage_crypto_ec.fun_3718 (10,751,003 samples, 0.04%) + + + +_mc_sha256_update (28,604,651 samples, 0.10%) + + + +caml_fill_bytes (90,652,006 samples, 0.32%) + + + +fiat_p256_cmovznz_u64 (96,743,700 samples, 0.34%) + + + +caml_ba_create (2,525,995 samples, 0.01%) + + + +Mirage_crypto_pk.Rsa.valid_prime_447 (6,375,214 samples, 0.02%) + + + +hrtimer_interrupt (2,561,706 samples, 0.01%) + + + +asm_sysvec_apic_timer_interrupt (2,563,290 samples, 0.01%) + + + +caml_main (27,137,512,258 samples, 94.62%) +caml_main + + +ml_z_probab_prime (21,658,520 samples, 0.08%) + + + +inversion (1,071,489,326 samples, 3.74%) +inve.. + + +Mirage_crypto_ec.select_855 (4,461,022 samples, 0.02%) + + + +inverse (1,148,594,487 samples, 4.00%) +inve.. + + +Mirage_crypto.Hash.hmaci_648 (133,153,612 samples, 0.46%) + + + +__gmpn_tdiv_qr (3,811,216 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (3,109,846 samples, 0.01%) + + + +Mirage_crypto_ec.share_inner_3264 (59,246,794 samples, 0.21%) + + + +__hrtimer_run_queues (3,191,993 samples, 0.01%) + + + +getrusage (19,719,153 samples, 0.07%) + + + +Mirage_crypto_pk.Z_extra.pseudoprime_251 (21,658,520 samples, 0.08%) + + + +ror32 (2,536,530 samples, 0.01%) + + + +Mirage_crypto_pk.Rsa.valid_prime_447 (7,621,886 samples, 0.03%) + + + +Cstruct.create_unsafe_790 (3,081,485 samples, 0.01%) + + + +__sysvec_apic_timer_interrupt (3,833,024 samples, 0.01%) + + + +mc_p256_point_add (9,469,389,328 samples, 33.02%) +mc_p256_point_add + + +fiat_p256_addcarryx_u64 (2,063,667,042 samples, 7.20%) +fiat_p256.. + + +entry_SYSCALL_64 (3,157,579 samples, 0.01%) + + + +Mirage_crypto_ec.go_1213 (135,068,826 samples, 0.47%) + + + +Mirage_crypto_ec.to_affine_804 (3,036,716 samples, 0.01%) + + + +ror32 (5,097,736 samples, 0.02%) + + + +fiat_p256_sub (9,565,680 samples, 0.03%) + + + +Mirage_crypto_ec.select_686 (2,465,444 samples, 0.01%) + + + +Mirage_crypto_ec.from_montgomery_668 (5,020,849 samples, 0.02%) + + + +caml_alloc_custom_mem (2,552,478 samples, 0.01%) + + + +fiat_p256_selectznz (85,506,559 samples, 0.30%) + + + +caml_program (27,136,143,757 samples, 94.61%) +caml_program + + +fiat_p256_value_barrier_u64 (7,636,629 samples, 0.03%) + + + +Mirage_crypto_ec.do_sign_1267 (3,184,538 samples, 0.01%) + + + +caml_start_program (27,136,143,757 samples, 94.61%) +caml_start_program + + +Cstruct.of_data_abstract_inner_2673 (9,545,924 samples, 0.03%) + + + +Mirage_crypto_ec.out_point_704 (436,062,940 samples, 1.52%) + + + +Mirage_crypto.Uncommon.rpad_664 (5,107,810 samples, 0.02%) + + + +fiat_p256_mul (3,213,806,897 samples, 11.21%) +fiat_p256_mul + + +inversion (10,835,812 samples, 0.04%) + + + +__memset_avx2_unaligned_erms (20,268,904 samples, 0.07%) + + + +caml_gc_dispatch (2,550,845 samples, 0.01%) + + + +sha256_do_chunk (19,742,601 samples, 0.07%) + + + +Mirage_crypto_ec.fun_3710 (4,380,461 samples, 0.02%) + + + +__gmpn_sbpi1_div_qr (5,715,069 samples, 0.02%) + + + +fiat_p256_divstep (1,058,747,791 samples, 3.69%) +fiat.. + + +point_double (10,772,660,191 samples, 37.56%) +point_double + + +Mirage_crypto.Hash.hmaci_648 (61,249,201 samples, 0.21%) + + + +fiat_p384_square (6,085,474 samples, 0.02%) + + + +caml_alloc_small_dispatch (8,071,866 samples, 0.03%) + + + +Mirage_crypto.Uncommon.clone_338 (13,996,984 samples, 0.05%) + + + +fiat_np256_mul (3,696,465 samples, 0.01%) + + + +fiat_p256_addcarryx_u64 (644,977,527 samples, 2.25%) +f.. + + +caml_gc_dispatch (10,788,051 samples, 0.04%) + + + +fiat_p256_square (85,932,694 samples, 0.30%) + + + +caml_ba_alloc (4,467,043 samples, 0.02%) + + + +Mirage_crypto.Uncommon.xor_639 (14,638,134 samples, 0.05%) + + + +__memset_avx2_unaligned_erms (48,936,536 samples, 0.17%) + + + +__gmpn_dcpi1_div_qr_n (12,127,789 samples, 0.04%) + + + +Mirage_crypto_ec.fun_3716 (14,003,564 samples, 0.05%) + + + +Mirage_crypto_ec.mul_653 (11,430,918 samples, 0.04%) + + + +mc_p256_point_add (59,131,587 samples, 0.21%) + + + +fiat_np256_mul (3,842,318 samples, 0.01%) + + + +caml_startup_common (27,136,824,272 samples, 94.61%) +caml_startup_common + + +sha256_do_chunk (30,356,717 samples, 0.11%) + + + +caml_empty_minor_heap (10,788,051 samples, 0.04%) + + + +syscall_return_via_sysret (8,275,034 samples, 0.03%) + + + +Mirage_crypto_ec.is_in_range_946 (3,736,636 samples, 0.01%) + + + +Stdlib.Bigarray.create_379 (3,829,518 samples, 0.01%) + + + +__gmpn_submul_1 (70,621,352 samples, 0.25%) + + + +ml_z_probab_prime (7,621,886 samples, 0.03%) + + + +fiat_p256_addcarryx_u64 (3,349,011,702 samples, 11.68%) +fiat_p256_addcarr.. + + +__GI___libc_malloc (3,778,912 samples, 0.01%) + + + +Mirage_crypto_ec.sign_1287 (24,488,112,743 samples, 85.38%) +Mirage_crypto_ec.sign_1287 + + +Mirage_crypto.Hash.finalize_545 (22,936,103 samples, 0.08%) + + + +mc_np256_mul (3,842,318 samples, 0.01%) + + + +Stdlib.Bytes.make_93 (337,026,206 samples, 1.18%) + + + +Mirage_crypto_ec.scalar_mult_956 (3,184,538 samples, 0.01%) + + + +__GI___libc_free (2,551,515 samples, 0.01%) + + + +inverse (14,029,971 samples, 0.05%) + + + +mc_p384_point_add (10,790,145 samples, 0.04%) + + + +Mirage_crypto.Uncommon.xor_639 (4,440,540 samples, 0.02%) + + + +Mirage_crypto.Hash.fun_1807 (14,637,402 samples, 0.05%) + + + +point_add (10,790,145 samples, 0.04%) + + + +Stdlib.Bytes.make_93 (67,179,861 samples, 0.23%) + + + +fiat_p256_subborrowx_u64 (444,156,832 samples, 1.55%) + + + +Mirage_crypto_ec.double_point_710 (11,322,410,430 samples, 39.48%) +Mirage_crypto_ec.double_point_710 + + +Eqaf.equal_178 (3,172,601 samples, 0.01%) + + + +fiat_p256_addcarryx_u64 (5,679,755 samples, 0.02%) + + + +alloc_custom_gen (3,177,783 samples, 0.01%) + + + +Mirage_crypto_pk.Dsa.fun_997 (21,658,520 samples, 0.08%) + + + +mc_p256_select (5,740,125 samples, 0.02%) + + + +_mc_sha256_update (30,972,386 samples, 0.11%) + + + +Mirage_crypto_ec.inv_682 (1,071,489,326 samples, 3.74%) +Mira.. + + +mc_p256_select (6,997,053 samples, 0.02%) + + + +sha256_do_chunk (2,558,404 samples, 0.01%) + + + +sysvec_apic_timer_interrupt (2,561,706 samples, 0.01%) + + + +caml_ba_alloc (7,636,247 samples, 0.03%) + + + +__gmpn_sqr_basecase (92,334,799 samples, 0.32%) + + + +caml_create_bytes (18,390,943 samples, 0.06%) + + + +point_double (3,198,101 samples, 0.01%) + + + +Mirage_crypto_ec.select_686 (749,112,120 samples, 2.61%) +Mi.. + + +Mirage_crypto.Hash.fun_1809 (2,558,404 samples, 0.01%) + + + +_mc_sha256_finalize (30,972,386 samples, 0.11%) + + + +Mirage_crypto_ec.fun_3874 (10,790,145 samples, 0.04%) + + + +caml_apply2 (12,622,409 samples, 0.04%) + + + +__sysvec_apic_timer_interrupt (2,561,706 samples, 0.01%) + + + +caml_apply2 (3,813,604 samples, 0.01%) + + + +fiat_p256_subborrowx_u64 (281,567,426 samples, 0.98%) + + + +mc_sha256_finalize (8,924,929 samples, 0.03%) + + + +inversion (14,029,971 samples, 0.05%) + + + +sha256_do_chunk (16,564,892 samples, 0.06%) + + + +caml_create_bytes (12,061,854 samples, 0.04%) + + + +fiat_p256_add (38,686,598 samples, 0.13%) + + + +Mirage_crypto_rng.Hmac_drbg.go_240 (40,734,508 samples, 0.14%) + + + +__libc_start_call_main (27,138,147,338 samples, 94.62%) +__libc_start_call_main + + +Mirage_crypto_ec.double_point_710 (30,869,301 samples, 0.11%) + + + +hrtimer_interrupt (4,472,202 samples, 0.02%) + + + +Mirage_crypto.Hash.fun_1807 (8,252,353 samples, 0.03%) + + + +caml_alloc_string (47,152,995 samples, 0.16%) + + + +fiat_p256_selectznz (117,696,205 samples, 0.41%) + + + +__GI___libc_malloc (2,535,538 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3720 (4,476,254 samples, 0.02%) + + + +caml_apply2 (4,465,188 samples, 0.02%) + + + +mc_sha256_finalize (19,742,601 samples, 0.07%) + + + +speed.exe (28,681,674,407 samples, 100.00%) +speed.exe + + +fiat_np256_mulx_u64 (2,557,929 samples, 0.01%) + + + +Mirage_crypto_pk.Rsa.fun_2060 (6,375,214 samples, 0.02%) + + + +fiat_np256_addcarryx_u64 (3,055,594 samples, 0.01%) + + + +__gmpz_tdiv_r (6,348,316 samples, 0.02%) + + + +Mirage_crypto_ec.sign_octets_1259 (186,904,424 samples, 0.65%) + + + +_mc_sha256_finalize (8,924,929 samples, 0.03%) + + + +Mirage_crypto.Hash.finalize_545 (18,472,108 samples, 0.06%) + + + +tick_sched_timer (3,202,270 samples, 0.01%) + + + +fiat_p256_subborrowx_u64 (100,030,935 samples, 0.35%) + + + +mc_sha256_finalize (2,558,404 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1809 (30,972,386 samples, 0.11%) + + + +caml_major_collection_slice (4,445,974 samples, 0.02%) + + + +point_double (8,220,000 samples, 0.03%) + + + +Stdlib.List.iter_261 (24,495,680,590 samples, 85.41%) +Stdlib.List.iter_261 + + +fiat_p256_add (1,662,853,484 samples, 5.80%) +fiat_p2.. + + +Stdlib.Bytes.make_93 (3,187,856 samples, 0.01%) + + + +ror32 (3,830,938 samples, 0.01%) + + + +Eqaf.compare_be_305 (2,558,512 samples, 0.01%) + + + +Stdlib.Bytes.make_93 (376,880,761 samples, 1.31%) + + + +Mirage_crypto_ec.from_montgomery_1102 (2,554,371 samples, 0.01%) + + + +Mirage_crypto_ec.inv_682 (3,036,716 samples, 0.01%) + + + +fiat_p521_square (8,882,560 samples, 0.03%) + + + +[speed.exe] (22,208,356 samples, 0.08%) + + + +fiat_p256_divstep (6,785,166 samples, 0.02%) + + + +fiat_p256_mul (73,246,105 samples, 0.26%) + + + +caml_apply3 (3,836,132 samples, 0.01%) + + + +fiat_p256_mulx_u64 (1,075,686,645 samples, 3.75%) +fiat.. + + +fiat_p521_mul (4,436,142 samples, 0.02%) + + + +caml_alloc_string (163,719,423 samples, 0.57%) + + + +Cstruct.create_919 (3,829,518 samples, 0.01%) + + + +Mirage_crypto.Hash.finalize_545 (10,846,917 samples, 0.04%) + + + +mc_p256_point_double (8,910,613 samples, 0.03%) + + + +_int_free (2,517,614 samples, 0.01%) + + + +__gmpn_sbpi1_div_qr (3,830,540 samples, 0.01%) + + + +Mirage_crypto_ec.x_of_finite_point_mod_n_1252 (1,105,692,995 samples, 3.86%) +Mira.. + + +fe_nz (5,732,736 samples, 0.02%) + + + +fiat_p256_subborrowx_u64 (249,396,326 samples, 0.87%) + + + +Cstruct.create_unsafe_790 (4,467,043 samples, 0.02%) + + + +ror32 (5,116,743 samples, 0.02%) + + + +mc_p256_point_double (10,821,203,286 samples, 37.73%) +mc_p256_point_double + + +mc_p256_inv (14,029,971 samples, 0.05%) + + + +caml_ba_create (10,805,569 samples, 0.04%) + + + +mc_sha256_finalize (29,244,042 samples, 0.10%) + + + +Stdlib.Bigarray.create_379 (3,081,485 samples, 0.01%) + + + +Mirage_crypto_ec.do_sign_1267 (24,291,662,395 samples, 84.69%) +Mirage_crypto_ec.do_sign_1267 + + +_mc_sha256_finalize (15,919,767 samples, 0.06%) + + + +caml_call_gc (2,550,845 samples, 0.01%) + + + +Mirage_crypto_ec.double_842 (6,402,377 samples, 0.02%) + + + +__getrusage (58,737,064 samples, 0.20%) + + + +mc_p256_point_double (3,700,924 samples, 0.01%) + + + +caml_create_bytes (30,172,406 samples, 0.11%) + + + +caml_alloc_small_dispatch (10,203,311 samples, 0.04%) + + + +Stdlib.Bigarray.create_379 (11,446,678 samples, 0.04%) + + + +task_sched_runtime (6,355,818 samples, 0.02%) + + + +fe_cmovznz (124,710,206 samples, 0.43%) + + + +__gmpz_stronglucas (21,658,520 samples, 0.08%) + + + +sysvec_apic_timer_interrupt (2,563,290 samples, 0.01%) + + + +__gmpn_sub_n (2,555,496 samples, 0.01%) + + + +mc_np256_to_montgomery (10,843,576 samples, 0.04%) + + + +Mirage_crypto_pk.Dh.s_group_489 (3,252,159 samples, 0.01%) + + + +Stdlib.Bigarray.create_379 (2,525,995 samples, 0.01%) + + + +Cstruct.of_data_abstract_inner_2673 (2,528,130 samples, 0.01%) + + + +[[stack]] (353,542,235 samples, 1.23%) + + + +asm_sysvec_apic_timer_interrupt (2,561,706 samples, 0.01%) + + + +Mirage_crypto_ec.select_855 (788,497,455 samples, 2.75%) +Mi.. + + +__gmpn_tdiv_qr (12,127,789 samples, 0.04%) + + + +__gmpn_fib2m (14,670,893 samples, 0.05%) + + + +fiat_np256_divstep (1,136,523,736 samples, 3.96%) +fiat.. + + +fiat_p256_from_montgomery (3,739,880 samples, 0.01%) + + + +point_double (108,649,433 samples, 0.38%) + + + +point_add (9,430,798,850 samples, 32.88%) +point_add + + +Dune.exe.Speed.count_436 (24,493,161,213 samples, 85.40%) +Dune.exe.Speed.count_436 + + +__GI___libc_free (4,429,130 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (148,385,470 samples, 0.52%) + + + +fiat_p256_square (46,111,144 samples, 0.16%) + + + +scheduler_tick (2,562,464 samples, 0.01%) + + + +sha256_do_chunk (14,853,921 samples, 0.05%) + + + +__memset_avx2_unaligned_erms (49,626,763 samples, 0.17%) + + + +mc_p256_point_double (3,807,892 samples, 0.01%) + + + +caml_empty_minor_heap (7,652,668 samples, 0.03%) + + + +Mirage_crypto.Hash.fun_1737 (32,266,631 samples, 0.11%) + + + +fiat_p256_addcarryx_u64 (1,766,848,642 samples, 6.16%) +fiat_p25.. + + +Dune.exe.Speed.go_236 (2,529,052,833 samples, 8.82%) +Dune.exe.Spe.. + + +mc_sha256_update (30,356,717 samples, 0.11%) + + + +mc_p384_point_double (8,220,000 samples, 0.03%) + + + +Mirage_crypto_ec.rev_string_292 (2,537,558 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1807 (15,494,806 samples, 0.05%) + + + +Stdlib.Bigarray.create_379 (4,467,043 samples, 0.02%) + + + +memset@plt (8,924,378 samples, 0.03%) + + + +Mirage_crypto.Hash.fun_1807 (16,564,892 samples, 0.06%) + + + +caml_alloc_string (21,578,112 samples, 0.08%) + + + +caml_c_call (19,776,271 samples, 0.07%) + + + +elf_dynamic_do_Rela (5,162,178 samples, 0.02%) + + + +caml_call_gc (3,835,221 samples, 0.01%) + + + +ror32 (6,385,140 samples, 0.02%) + + + +__gmpn_addmul_2 (54,857,989 samples, 0.19%) + + + +caml_fill_bytes (92,615,502 samples, 0.32%) + + + +Mirage_crypto_ec.fun_3759 (3,696,465 samples, 0.01%) + + + +_mc_sha256_update (8,252,353 samples, 0.03%) + + + +caml_alloc_small_dispatch (2,550,845 samples, 0.01%) + + + +fiat_np256_addcarryx_u64 (6,367,439 samples, 0.02%) + + + +all (28,681,704,248 samples, 100%) + + + +fiat_p256_square (5,079,409,167 samples, 17.71%) +fiat_p256_square + + +mc_p521_point_double (15,219,841 samples, 0.05%) + + + +Mirage_crypto.Hash.finalize_545 (5,723,857 samples, 0.02%) + + + +Mirage_crypto_ec.rev_string_292 (2,550,814 samples, 0.01%) + + + +inversion (1,148,594,487 samples, 4.00%) +inve.. + + +Cstruct.create_unsafe_790 (3,829,518 samples, 0.01%) + + + +Mirage_crypto_ec.add_point_714 (9,685,600,126 samples, 33.77%) +Mirage_crypto_ec.add_point_714 + + +caml_ba_create (4,467,043 samples, 0.02%) + + + +Stdlib.Bigarray.create_379 (4,436,806 samples, 0.02%) + + + +tick_sched_timer (3,191,993 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1807 (30,356,717 samples, 0.11%) + + + +Cstruct.create_unsafe_790 (2,552,341 samples, 0.01%) + + + +Stdlib.Bytes.make_93 (162,365,271 samples, 0.57%) + + + +fiat_np256_from_montgomery (2,554,371 samples, 0.01%) + + + +fiat_p521_addcarryx_u64 (8,254,158 samples, 0.03%) + + + +mc_np256_mul (3,696,465 samples, 0.01%) + + + +fiat_p256_mul (57,566,083 samples, 0.20%) + + + +__gmpn_copyi (2,543,104 samples, 0.01%) + + + +do_syscall_64 (46,669,117 samples, 0.16%) + + + +Eqaf.compare_be_305 (6,943,608 samples, 0.02%) + + + +point_double (3,700,924 samples, 0.01%) + + + +_mc_sha256_update (19,742,601 samples, 0.07%) + + + +Mirage_crypto_ec.fun_3720 (9,470,030,502 samples, 33.02%) +Mirage_crypto_ec.fun_3720 + + +Mirage_crypto_ec.fun_3771 (2,554,371 samples, 0.01%) + + + +Mirage_crypto_ec.scalar_mult_956 (59,246,794 samples, 0.21%) + + + +__gmpz_millerrabin (21,658,520 samples, 0.08%) + + + +Mirage_crypto_pk.Dsa.priv_342 (23,567,687 samples, 0.08%) + + + +Mirage_crypto_ec.fun_3694 (7,602,052 samples, 0.03%) + + + +[unknown] (379,318,757 samples, 1.32%) + + + +Cstruct.concat_1395 (5,016,780 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (113,550,067 samples, 0.40%) + + + +mc_sha256_update (15,494,806 samples, 0.05%) + + + +fiat_p521_mulx_u64 (2,537,748 samples, 0.01%) + + + +caml_apply4 (21,629,185 samples, 0.08%) + + + +main (27,138,147,338 samples, 94.62%) +main + + +Mirage_crypto_ec.rev_string_292 (6,396,211 samples, 0.02%) + + + +fiat_np256_to_montgomery (3,174,539 samples, 0.01%) + + + +Cstruct.create_unsafe_790 (4,436,806 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3763 (1,148,594,487 samples, 4.00%) +Mira.. + + +Mirage_crypto.Hash.hmaci_648 (29,251,396 samples, 0.10%) + + + +__gmpz_stronglucas (5,746,100 samples, 0.02%) + + + +__gmpz_lucas_mod (6,354,270 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3718 (3,700,924 samples, 0.01%) + + + +Mirage_crypto_pk.Rsa.priv_of_primes_502 (7,621,886 samples, 0.03%) + + + +caml_sys_time_unboxed (61,889,921 samples, 0.22%) + + + +caml_ba_alloc (2,538,159 samples, 0.01%) + + + +fiat_np256_value_barrier_u64 (6,395,252 samples, 0.02%) + + + +Mirage_crypto_ec.out_point_704 (9,574,868 samples, 0.03%) + + + +caml_ba_create (2,542,421 samples, 0.01%) + + + +Mirage_crypto_ec.select_855 (2,465,444 samples, 0.01%) + + + +__gmpz_lucas_mod (6,987,627 samples, 0.02%) + + + +caml_empty_minor_heap (2,434,916 samples, 0.01%) + + + +__gmpn_strongfibo (3,830,540 samples, 0.01%) + + + +mc_p256_inv (1,071,489,326 samples, 3.74%) +mc_p.. + + +Cstruct.create_unsafe_790 (3,821,141 samples, 0.01%) + + + +Mirage_crypto.Uncommon.clone_338 (3,180,757 samples, 0.01%) + + + +_dl_start (6,084,015 samples, 0.02%) + + + +asm_sysvec_apic_timer_interrupt (5,113,728 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (55,898,391 samples, 0.19%) + + + +Mirage_crypto_ec.add_point_714 (25,912,049 samples, 0.09%) + + + +fiat_p384_addcarryx_u64 (5,012,431 samples, 0.02%) + + + +Stdlib.Bigarray.create_379 (3,109,846 samples, 0.01%) + + + +caml_ba_alloc (3,196,331 samples, 0.01%) + + + +caml_fill_bytes (16,522,222 samples, 0.06%) + + + +fiat_np256_addcarryx_u64 (3,154,810 samples, 0.01%) + + + +Mirage_crypto_ec.out_point_704 (186,985,191 samples, 0.65%) + + + +fiat_np256_divstep (26,076,512 samples, 0.09%) + + + +caml_ba_alloc (2,542,421 samples, 0.01%) + + + +sha256_do_chunk (8,284,177 samples, 0.03%) + + + +Mirage_crypto.Uncommon.clone_338 (5,094,606 samples, 0.02%) + + + +Mirage_crypto_ec.fun_3716 (306,642,652 samples, 1.07%) + + + +fiat_p521_addcarryx_u64 (7,626,018 samples, 0.03%) + + + +__gmpz_stronglucas (6,993,012 samples, 0.02%) + + + +fiat_p256_subborrowx_u64 (197,115,664 samples, 0.69%) + + + +sysvec_apic_timer_interrupt (5,113,728 samples, 0.02%) + + + +sha256_do_chunk (7,003,862 samples, 0.02%) + + + +caml_ba_create (8,269,203 samples, 0.03%) + + + +entry_SYSCALL_64_after_hwframe (46,669,117 samples, 0.16%) + + + +mc_np256_inv (1,148,594,487 samples, 4.00%) +mc_n.. + + +fiat_p256_subborrowx_u64 (387,021,142 samples, 1.35%) + + + +fiat_p256_cmovznz_u64 (148,212,791 samples, 0.52%) + + + +Mirage_crypto_ec.to_octets_828 (3,036,716 samples, 0.01%) + + + +Mirage_crypto_ec.sign_1287 (3,126,080 samples, 0.01%) + + + +fiat_p256_mul (7,602,052 samples, 0.03%) + + + +hrtimer_interrupt (3,833,024 samples, 0.01%) + + + +caml_gc_dispatch (7,652,668 samples, 0.03%) + + + +fe_cmovznz (85,506,559 samples, 0.30%) + + + +Mirage_crypto.Hash.fun_1807 (29,138,276 samples, 0.10%) + + + +Mirage_crypto_ec.scalar_mult_956 (7,013,117 samples, 0.02%) + + + +sha256_do_chunk (8,252,353 samples, 0.03%) + + + +caml_apply3 (9,375,249 samples, 0.03%) + + + +caml_fill_bytes (41,095,069 samples, 0.14%) + + + +Mirage_crypto_ec.from_be_octets_1078 (14,035,682 samples, 0.05%) + + + +Mirage_crypto.Hash.fun_1809 (29,244,042 samples, 0.10%) + + + +mc_p256_select (3,177,746 samples, 0.01%) + + + +sha256_do_chunk (30,331,172 samples, 0.11%) + + + +fiat_p256_mulx_u64 (695,474,823 samples, 2.42%) +fi.. + + +fiat_p256_mul (5,650,648,126 samples, 19.70%) +fiat_p256_mul + + +tick_sched_handle (2,562,464 samples, 0.01%) + + + +Mirage_crypto_ec.to_montgomery_1106 (3,815,474 samples, 0.01%) + + + +caml_ba_create (3,109,846 samples, 0.01%) + + + +fiat_p384_mul (6,940,216 samples, 0.02%) + + + +caml_alloc_string (171,098,132 samples, 0.60%) + + + +fiat_p256_addcarryx_u64 (159,606,047 samples, 0.56%) + + + +memset@plt (10,845,965 samples, 0.04%) + + + +caml_ba_alloc (4,436,806 samples, 0.02%) + + + +Mirage_crypto_ec.sign_1287 (3,184,538 samples, 0.01%) + + + +__gmpz_probab_prime_p (7,621,886 samples, 0.03%) + + + +Mirage_crypto_rng.Hmac_drbg.reseed_174 (176,115,063 samples, 0.61%) + + + +Mirage_crypto_ec.139 (5,635,774 samples, 0.02%) + + + +Cstruct.create_919 (5,690,265 samples, 0.02%) + + + +Cstruct.create_unsafe_790 (3,165,453 samples, 0.01%) + + + +fiat_p256_mulx_u64 (1,236,480,028 samples, 4.31%) +fiat_.. + + +ror32 (6,928,002 samples, 0.02%) + + + +update_process_times (2,562,464 samples, 0.01%) + + + +memset@plt (18,327,775 samples, 0.06%) + + + +fiat_p256_cmovznz_u64 (74,934,150 samples, 0.26%) + + + +Mirage_crypto.Hash.fun_1809 (8,924,929 samples, 0.03%) + + + +fiat_p384_addcarryx_u64 (4,861,350 samples, 0.02%) + + + +point_add (50,229,941 samples, 0.18%) + + + +mc_p256_select (276,026,202 samples, 0.96%) + + + +Mirage_crypto_ec.bit_at_467 (22,230,480 samples, 0.08%) + + + +Mirage_crypto_ec.fun_3718 (10,821,203,286 samples, 37.73%) +Mirage_crypto_ec.fun_3718 + + +fiat_np256_addcarryx_u64 (394,479,447 samples, 1.38%) + + + +fiat_p256_cmovznz_u64 (7,636,629 samples, 0.03%) + + + +__gmpn_tdiv_qr (5,715,069 samples, 0.02%) + + + +Mirage_crypto_pk.Dh.entry (3,252,159 samples, 0.01%) + + + +fiat_p256_sub (57,766,905 samples, 0.20%) + + + +caml_ba_alloc (2,552,660 samples, 0.01%) + + + +fiat_p256_subborrowx_u64 (689,908,622 samples, 2.41%) +fi.. + + +__gmpz_probab_prime_p (21,658,520 samples, 0.08%) + + + +caml_empty_minor_heap (2,550,845 samples, 0.01%) + + + +mc_sha256_update (16,564,892 samples, 0.06%) + + + +mc_p256_select (6,375,219 samples, 0.02%) + + + +fiat_p256_cmovznz_u64 (90,664,649 samples, 0.32%) + + + +dl_main (6,084,015 samples, 0.02%) + + + +mark_slice (3,172,197 samples, 0.01%) + + + +caml_gc_dispatch (2,562,227 samples, 0.01%) + + + +Dune.exe.Speed.fun_2371 (24,494,411,698 samples, 85.40%) +Dune.exe.Speed.fun_2371 + + +Mirage_crypto.Hash.fun_1807 (7,003,862 samples, 0.02%) + + + +fiat_p256_subborrowx_u64 (396,142,632 samples, 1.38%) + + + +__gmpn_dcpi1_div_qr (12,127,789 samples, 0.04%) + + + +[anon] (458,504,802 samples, 1.60%) + + + +_mc_sha256_update (16,564,892 samples, 0.06%) + + + +Mirage_crypto_ec.fun_3714 (1,071,489,326 samples, 3.74%) +Mira.. + + +fiat_p256_square (2,458,048 samples, 0.01%) + + + +caml_call_gc (3,075,953 samples, 0.01%) + + + +__gmpn_fib2m (3,830,540 samples, 0.01%) + + + +Mirage_crypto.Hash.fun_1809 (15,919,767 samples, 0.06%) + + + +Mirage_crypto_ec.fun_3773 (10,843,576 samples, 0.04%) + + + +caml_empty_minor_heap (5,063,764 samples, 0.02%) + + + +Mirage_crypto_ec.fun_4028 (12,061,825 samples, 0.04%) + + + +caml_fill_bytes (17,106,951 samples, 0.06%) + + + +elf_machine_rela_relative (3,760,172 samples, 0.01%) + + + +asm_sysvec_apic_timer_interrupt (5,110,529 samples, 0.02%) + + + +__gmpz_millerrabin (6,993,012 samples, 0.02%) + + + +Stdlib.Bytes.make_93 (25,538,697 samples, 0.09%) + + + +sha256_do_chunk (29,138,276 samples, 0.10%) + + + +thread_group_cputime (8,271,771 samples, 0.03%) + + + +_start (27,144,231,353 samples, 94.64%) +_start + + +mc_p224_point_double (3,728,536 samples, 0.01%) + + + +__sysvec_apic_timer_interrupt (4,472,202 samples, 0.02%) + + + +Cstruct.create_unsafe_790 (3,193,502 samples, 0.01%) + + + +_mc_sha256_update (29,138,276 samples, 0.10%) + + + +Mirage_crypto_ec.do_sign_1267 (3,126,080 samples, 0.01%) + + + +Mirage_crypto_ec.fun_3759 (3,842,318 samples, 0.01%) + + + +tick_sched_timer (2,561,706 samples, 0.01%) + + + +mc_sha256_update (8,252,353 samples, 0.03%) + + + +Dune.exe.Speed.entry (27,130,268,667 samples, 94.59%) +Dune.exe.Speed.entry + + +__gmpz_tdiv_r (5,087,961 samples, 0.02%) + + + +caml_c_call (22,208,356 samples, 0.08%) + + + +sha256_do_chunk (15,288,439 samples, 0.05%) + + + +asm_sysvec_apic_timer_interrupt (4,483,294 samples, 0.02%) + + + +Cstruct.create_unsafe_790 (3,180,757 samples, 0.01%) + + + + \ No newline at end of file