Skip to content

avoid dynamic memory allocation #5

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
jhunsaker wants to merge 4 commits into
base: monad
Choose a base branch
from
Draft

avoid dynamic memory allocation #5

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
524906c
fix build
rgarc Jun 9, 2023
683b1dc
missing include
jhunsaker Aug 25, 2023
2fd22aa
thread local secp256k1 context
jhunsaker Aug 25, 2023
413ceb1
avoid dynamic memory allocation
jhunsaker Aug 24, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions lib/CMakeLists.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,8 +14,8 @@
limitations under the License.
]]

find_package(ethash CONFIG REQUIRED)
find_package(intx CONFIG REQUIRED)
#find_package(ethash CONFIG REQUIRED)
#find_package(intx CONFIG REQUIRED)

add_library(silkpre
silkpre/blake2b.c
Expand Down
84 changes: 56 additions & 28 deletions lib/silkpre/precompile.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,9 +19,11 @@
#include <gmp.h>

#include <algorithm>
#include <array>
#include <bit>
#include <cstring>
#include <limits>
#include <string_view>

#include <intx/intx.hpp>
#include <libff/algebra/curves/alt_bn128/alt_bn128_pairing.hpp>
Expand Down Expand Up @@ -50,8 +52,13 @@ uint64_t silkpre_ecrec_gas(const uint8_t*, size_t, int) { return 3'000; }
SilkpreOutput silkpre_ecrec_run(const uint8_t* input, size_t len) {
uint8_t* out{static_cast<uint8_t*>(std::malloc(32))};

std::basic_string<uint8_t> d(input, len);
right_pad(d, 128);
std::basic_string_view<uint8_t> d{input, len};
uint8_t d_pad[128];
if (INTX_UNLIKELY(len < 128)) {
std::memcpy(d_pad, input, len);
std::memset(d_pad + len, '\0', 128 - len);
d = {d_pad, 128};
}

const auto v{intx::be::unsafe::load<intx::uint256>(&d[32])};
const auto r{intx::be::unsafe::load<intx::uint256>(&d[64])};
Expand All @@ -67,7 +74,7 @@ SilkpreOutput silkpre_ecrec_run(const uint8_t* input, size_t len) {
}

std::memset(out, 0, 12);
static secp256k1_context* context{secp256k1_context_create(SILKPRE_SECP256K1_CONTEXT_FLAGS)};
thread_local secp256k1_context* context{secp256k1_context_create(SILKPRE_SECP256K1_CONTEXT_FLAGS)};
if (!silkpre_recover_address(out + 12, &d[0], &d[64], v != 27, context)) {
return {out, 0};
}
Expand Down Expand Up @@ -118,8 +125,13 @@ static intx::uint256 mult_complexity_eip2565(const intx::uint256& max_length) no
uint64_t silkpre_expmod_gas(const uint8_t* ptr, size_t len, int rev) {
const uint64_t min_gas{rev < EVMC_BERLIN ? 0 : 200u};

std::basic_string<uint8_t> input(ptr, len);
right_pad(input, 3 * 32);
std::basic_string_view<uint8_t> input{ptr, len};
uint8_t input_pad[96];
if (INTX_UNLIKELY(len < 96)) {
std::memcpy(input_pad, ptr, len);
std::memset(input_pad + len, '\0', 96 - len);
input = {input_pad, 96};
}

intx::uint256 base_len256{intx::be::unsafe::load<intx::uint256>(&input[0])};
intx::uint256 exp_len256{intx::be::unsafe::load<intx::uint256>(&input[32])};
Expand All @@ -137,15 +149,20 @@ uint64_t silkpre_expmod_gas(const uint8_t* ptr, size_t len, int rev) {
uint64_t base_len64{static_cast<uint64_t>(base_len256)};
uint64_t exp_len64{static_cast<uint64_t>(exp_len256)};

input.erase(0, 3 * 32);
input.remove_prefix(96);

intx::uint256 exp_head{0}; // first 32 bytes of the exponent
if (input.length() > base_len64) {
input.erase(0, base_len64);
right_pad(input, 3 * 32);
intx::uint256 exp_head{0}; // first 32 bytes of the exponent
if (input.length() > base_len64) { // input cannot be input_pad
input.remove_prefix(base_len64);
if (INTX_UNLIKELY(input.size() < 32)) {
std::memcpy(input_pad, input.data(), input.size());
std::memset(input_pad + input.size(), '\0', 32 - input.size());
input = {input_pad, 32};
}
if (exp_len64 < 32) {
input.erase(exp_len64);
input.insert(0, 32 - exp_len64, '\0');
std::memset(input_pad, '\0', 32 - exp_len64);
std::memmove(input_pad + (32 - exp_len64), input.data(), exp_len64);
input = {input_pad, 32};
}
exp_head = intx::be::unsafe::load<intx::uint256>(input.data());
}
Expand Down Expand Up @@ -341,9 +358,10 @@ static std::optional<libff::alt_bn128_G2> decode_g2_element(const uint8_t bytes_
return point;
}

static std::basic_string<uint8_t> encode_g1_element(libff::alt_bn128_G1 p) noexcept {
std::basic_string<uint8_t> out(64, '\0');
static std::array<uint8_t, 64> encode_g1_element(libff::alt_bn128_G1 p) noexcept {
std::array<uint8_t, 64> out;
if (p.is_zero()) {
out.fill('\0');
return out;
}

Expand All @@ -364,9 +382,14 @@ static std::basic_string<uint8_t> encode_g1_element(libff::alt_bn128_G1 p) noexc

uint64_t silkpre_bn_add_gas(const uint8_t*, size_t, int rev) { return rev >= EVMC_ISTANBUL ? 150 : 500; }

SilkpreOutput silkpre_bn_add_run(const uint8_t* ptr, size_t len) {
std::basic_string<uint8_t> input(ptr, len);
right_pad(input, 128);
SilkpreOutput silkpre_bn_add_run(const uint8_t* const ptr, const size_t len) {
std::basic_string_view<uint8_t> input{ptr, len};
uint8_t input_pad[128];
if (INTX_UNLIKELY(len < 128)) {
std::memcpy(input_pad, ptr, len);
std::memset(input_pad + len, '\0', 128 - len);
input = {input_pad, 128};
}

init_libff();

Expand All @@ -381,18 +404,23 @@ SilkpreOutput silkpre_bn_add_run(const uint8_t* ptr, size_t len) {
}

libff::alt_bn128_G1 sum{*x + *y};
const std::basic_string<uint8_t> res{encode_g1_element(sum)};
const auto res{encode_g1_element(sum)};

uint8_t* out{static_cast<uint8_t*>(std::malloc(res.length()))};
std::memcpy(out, res.data(), res.length());
return {out, res.length()};
uint8_t* out{static_cast<uint8_t*>(std::malloc(res.size()))};
std::memcpy(out, res.data(), res.size());
return {out, res.size()};
}

uint64_t silkpre_bn_mul_gas(const uint8_t*, size_t, int rev) { return rev >= EVMC_ISTANBUL ? 6'000 : 40'000; }

SilkpreOutput silkpre_bn_mul_run(const uint8_t* ptr, size_t len) {
std::basic_string<uint8_t> input(ptr, len);
right_pad(input, 96);
SilkpreOutput silkpre_bn_mul_run(const uint8_t* const ptr, const size_t len) {
std::basic_string_view<uint8_t> input{ptr, len};
uint8_t input_pad[96];
if (INTX_UNLIKELY(len < 96)) {
std::memcpy(input_pad, ptr, len);
std::memset(input_pad + len, '\0', 96 - len);
input = {input_pad, 96};
}

init_libff();

Expand All @@ -404,11 +432,11 @@ SilkpreOutput silkpre_bn_mul_run(const uint8_t* ptr, size_t len) {
Scalar n{to_scalar(&input[64])};

libff::alt_bn128_G1 product{n * *x};
const std::basic_string<uint8_t> res{encode_g1_element(product)};
const auto res{encode_g1_element(product)};

uint8_t* out{static_cast<uint8_t*>(std::malloc(res.length()))};
std::memcpy(out, res.data(), res.length());
return {out, res.length()};
uint8_t* out{static_cast<uint8_t*>(std::malloc(res.size()))};
std::memcpy(out, res.data(), res.size());
return {out, res.size()};
}

static constexpr size_t kSnarkvStride{192};
Expand Down
1 change: 1 addition & 0 deletions test/hex.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@
#include "hex.hpp"

#include <cassert>
#include <stdexcept>

std::string to_hex(const uint8_t* bytes, size_t len) {
static const char* kHexDigits{"0123456789abcdef"};
Expand Down