Merge branch 'main' into stf-slashings-penalties

Author: GrapeBaBa

bench/state_transition/process_block.zig

@@ -15,8 +15,8 @@ const era = @import("era");
 const preset = state_transition.preset;
 const ForkSeq = config.ForkSeq;
 const CachedBeaconState = state_transition.CachedBeaconState;
-const ForkBeaconBlock = fork_types.ForkBeaconBlock;
-const ForkBeaconBlockBody = fork_types.ForkBeaconBlockBody;
+const BeaconBlock = fork_types.BeaconBlock;
+const BeaconBlockBody = fork_types.BeaconBlockBody;
 const ValidatorIndex = types.primitive.ValidatorIndex.Type;
 const PubkeyIndexMap = state_transition.PubkeyIndexMap(ValidatorIndex);
 const Withdrawals = types.capella.Withdrawals.Type;
@@ -33,7 +33,7 @@ const BenchOpts = struct {
 fn ProcessBlockHeaderBench(comptime fork: ForkSeq) type {
     return struct {
         cached_state: *CachedBeaconState,
-        block: *const ForkBeaconBlock(fork, .full),
+        block: *const BeaconBlock(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -56,7 +56,7 @@ fn ProcessBlockHeaderBench(comptime fork: ForkSeq) type {
 fn ProcessWithdrawalsBench(comptime fork: ForkSeq) type {
     return struct {
         cached_state: *CachedBeaconState,
-        body: *const ForkBeaconBlockBody(fork, .full),
+        body: *const BeaconBlockBody(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -101,7 +101,7 @@ fn ProcessWithdrawalsBench(comptime fork: ForkSeq) type {
 fn ProcessExecutionPayloadBench(comptime fork: ForkSeq) type {
     return struct {
         cached_state: *CachedBeaconState,
-        body: *const ForkBeaconBlockBody(fork, .full),
+        body: *const BeaconBlockBody(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -127,8 +127,8 @@ fn ProcessExecutionPayloadBench(comptime fork: ForkSeq) type {
 fn ProcessRandaoBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type {
     return struct {
         cached_state: *CachedBeaconState,
-        block: *const ForkBeaconBlock(fork, .full),
-        body: *const ForkBeaconBlockBody(fork, .full),
+        block: *const BeaconBlock(.full, fork),
+        body: *const BeaconBlockBody(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -153,7 +153,7 @@ fn ProcessRandaoBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type {
 fn ProcessEth1DataBench(comptime fork: ForkSeq) type {
     return struct {
         cached_state: *CachedBeaconState,
-        body: *const ForkBeaconBlockBody(fork, .full),
+        body: *const BeaconBlockBody(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -173,7 +173,7 @@ fn ProcessEth1DataBench(comptime fork: ForkSeq) type {
 fn ProcessOperationsBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type {
     return struct {
         cached_state: *CachedBeaconState,
-        body: *const ForkBeaconBlockBody(fork, .full),
+        body: *const BeaconBlockBody(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -198,7 +198,7 @@ fn ProcessOperationsBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type
 fn ProcessSyncAggregateBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type {
     return struct {
         cached_state: *CachedBeaconState,
-        body: *const ForkBeaconBlockBody(fork, .full),
+        body: *const BeaconBlockBody(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -222,7 +222,7 @@ fn ProcessSyncAggregateBench(comptime fork: ForkSeq, comptime opts: BenchOpts) t
 fn ProcessBlockBench(comptime fork: ForkSeq, comptime opts: BenchOpts) type {
     return struct {
         cached_state: *CachedBeaconState,
-        block: *const ForkBeaconBlock(fork, .full),
+        block: *const BeaconBlock(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -302,8 +302,8 @@ fn printSegmentStats(stdout: anytype) !void {
 fn ProcessBlockSegmentedBench(comptime fork: ForkSeq) type {
     return struct {
         cached_state: *CachedBeaconState,
-        block: *const ForkBeaconBlock(fork, .full),
-        body: *const ForkBeaconBlockBody(fork, .full),
+        block: *const BeaconBlock(.full, fork),
+        body: *const BeaconBlockBody(.full, fork),
 
         pub fn run(self: @This(), allocator: std.mem.Allocator) void {
             const cloned = self.cached_state.clone(allocator, .{}) catch unreachable;
@@ -501,9 +501,7 @@ fn runBenchmark(comptime fork: ForkSeq, allocator: std.mem.Allocator, pool: *Nod
 
     try state_transition.state_transition.processSlots(
         allocator,
-        cached_state.config,
-        cached_state.getEpochCache(),
-        cached_state.state,
+        cached_state,
         block_slot,
         .{},
     );

bench/state_transition/process_epoch.zig

@@ -129,7 +129,7 @@ fn ProcessSlashingsBench(comptime fork: ForkSeq) type {
                 cloned.getEpochCache(),
                 cloned.state.castToFork(fork),
                 &cache,
-                false,
+                true,
             ) catch unreachable;
         }
     };

build.zig

@@ -56,6 +56,16 @@ pub fn build(b: *std.Build) void {
         .target = target,
     });
 
+    const dep_metrics = b.dependency("metrics", .{
+        .optimize = optimize,
+        .target = target,
+    });
+
+    const dep_httpz = b.dependency("httpz", .{
+        .optimize = optimize,
+        .target = target,
+    });
+
     const module_constants = b.createModule(.{
         .root_source_file = b.path("src/constants/root.zig"),
         .target = target,
@@ -156,6 +166,29 @@ pub fn build(b: *std.Build) void {
     const tls_run_exe_download_era_files = b.step("run:download_era_files", "Run the download_era_files executable");
     tls_run_exe_download_era_files.dependOn(&run_exe_download_era_files.step);
 
+    const module_metrics_era = b.createModule(.{
+        .root_source_file = b.path("examples/metrics_era.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    b.modules.put(b.dupe("metrics_era"), module_metrics_era) catch @panic("OOM");
+
+    const exe_metrics_era = b.addExecutable(.{
+        .name = "metrics_era",
+        .root_module = module_metrics_era,
+    });
+
+    const install_exe_metrics_era = b.addInstallArtifact(exe_metrics_era, .{});
+
+    const tls_install_exe_metrics_era = b.step("build-exe:metrics_era", "Install the metrics_era executable");
+    tls_install_exe_metrics_era.dependOn(&install_exe_metrics_era.step);
+    b.getInstallStep().dependOn(&install_exe_metrics_era.step);
+
+    const run_exe_metrics_era = b.addRunArtifact(exe_metrics_era);
+    if (b.args) |args| run_exe_metrics_era.addArgs(args);
+    const tls_run_exe_metrics_era = b.step("run:metrics_era", "Run the metrics_era executable");
+    tls_run_exe_metrics_era.dependOn(&run_exe_metrics_era.step);
+
     const module_download_spec_tests = b.createModule(.{
         .root_source_file = b.path("test/spec/download_spec_tests.zig"),
         .target = target,
@@ -604,6 +637,20 @@ pub fn build(b: *std.Build) void {
     tls_run_test_download_era_files.dependOn(&run_test_download_era_files.step);
     tls_run_test.dependOn(&run_test_download_era_files.step);
 
+    const test_metrics_era = b.addTest(.{
+        .name = "metrics_era",
+        .root_module = module_metrics_era,
+        .filters = b.option([][]const u8, "metrics_era.filters", "metrics_era test filters") orelse &[_][]const u8{},
+    });
+    const install_test_metrics_era = b.addInstallArtifact(test_metrics_era, .{});
+    const tls_install_test_metrics_era = b.step("build-test:metrics_era", "Install the metrics_era test");
+    tls_install_test_metrics_era.dependOn(&install_test_metrics_era.step);
+
+    const run_test_metrics_era = b.addRunArtifact(test_metrics_era);
+    const tls_run_test_metrics_era = b.step("test:metrics_era", "Run the metrics_era test");
+    tls_run_test_metrics_era.dependOn(&run_test_metrics_era.step);
+    tls_run_test.dependOn(&run_test_metrics_era.step);
+
     const test_download_spec_tests = b.addTest(.{
         .name = "download_spec_tests",
         .root_module = module_download_spec_tests,
@@ -907,9 +954,18 @@ pub fn build(b: *std.Build) void {
     module_state_transition.addImport("constants", module_constants);
     module_state_transition.addImport("hex", module_hex);
     module_state_transition.addImport("persistent_merkle_tree", module_persistent_merkle_tree);
+    module_state_transition.addImport("metrics", dep_metrics.module("metrics"));
 
     module_download_era_files.addImport("download_era_options", options_module_download_era_options);
 
+    module_metrics_era.addImport("consensus_types", module_consensus_types);
+    module_metrics_era.addImport("state_transition", module_state_transition);
+    module_metrics_era.addImport("download_era_options", options_module_download_era_options);
+    module_metrics_era.addImport("era", module_era);
+    module_metrics_era.addImport("config", module_config);
+    module_metrics_era.addImport("preset", module_preset);
+    module_metrics_era.addImport("httpz", dep_httpz.module("httpz"));
+
     module_download_spec_tests.addImport("spec_test_options", options_module_spec_test_options);
 
     module_write_spec_tests.addImport("spec_test_options", options_module_spec_test_options);

build.zig.zon

@@ -26,6 +26,14 @@
             .url = "git+https://github.com/hendriknielaender/zBench#d8c7dd485306b88b757d52005614ebcb0a336942",
             .hash = "zbench-0.10.0-YTdc714iAQDO4lTHMnIljYHPZ5v_sNTsw75vAmO1pyT-",
         },
+        .metrics = .{
+            .url = "git+https://github.com/karlseguin/metrics.zig.git#5f5420c98378a873a4bf816d69772c8f708a2273",
+            .hash = "metrics-0.0.0-W7G4eHzVAQBMD2Iz5KUoKTssfqAloxCVd7xdG0gt1j5w",
+        },
+        .httpz = .{
+            .url = "git+https://github.com/karlseguin/http.zig.git#2924ead41db9e1986db3b4909a82185c576f6361",
+            .hash = "httpz-0.0.0-PNVzrC7CBgDSMZNP7chgAczR3FyAz5Eum6Kb1_K9kmYR",
+        },
     },
     .paths = .{ "build.zig", "build.zig.zon", "src" },
 }

examples/metrics_era.zig

@@ -0,0 +1,160 @@
+//! Simple example to show collection of metrics using metrics.zig, with mainnet era files.
+//!
+//! Metrics are served on `port` on a separate thread, which is visualized through Prometheus,
+//! while we continuously run the state transition function using data from 2 consecutive era files.
+//! Run a Prometheus instance to see the data visually.
+//!
+//! To run this example, we first require era files: `zig build run:download_era_files`.
+//!
+//! Then, run `zig build run:metrics_era`.
+//!
+//! Note: this example is mainly meant to test that our metrics is working; realistically we do not need
+//! such an example. The bulk of this code should be moved to our beacon node implementation once it's ready.
+
+const download_era_options = @import("download_era_options");
+const era = @import("era");
+const c = @import("config");
+const std = @import("std");
+const httpz = @import("httpz");
+const state_transition = @import("state_transition");
+const types = @import("consensus_types");
+
+const CachedBeaconState = state_transition.CachedBeaconState;
+const SignedBlock = state_transition.SignedBlock;
+const active_preset = @import("preset").active_preset;
+const mainnet_chain_config = @import("config").mainnet.chain_config;
+const minimal_chain_config = @import("config").minimal.chain_config;
+const BeaconConfig = @import("config").BeaconConfig;
+const ValidatorIndex = @import("consensus_types").primitive.ValidatorIndex.Type;
+const Index2PubkeyCache = state_transition.Index2PubkeyCache;
+const PubkeyIndexMap = state_transition.PubkeyIndexMap(ValidatorIndex);
+const chain_config = if (active_preset == .mainnet) mainnet_chain_config else minimal_chain_config;
+
+const MetricsHandler = struct {
+    allocator: std.mem.Allocator,
+};
+
+pub fn serveMetrics(
+    allocator: std.mem.Allocator,
+    port: u16,
+) !void {
+    var handler = MetricsHandler{
+        .allocator = allocator,
+    };
+    const address = "0.0.0.0";
+    var server = try httpz.Server(*MetricsHandler).init(
+        allocator,
+        .{ .port = port, .address = address, .thread_pool = .{ .count = 1 } },
+        &handler,
+    );
+    defer {
+        server.stop();
+        server.deinit();
+    }
+    var router = try server.router(.{});
+    router.get("/metrics", getMetrics, .{});
+
+    std.log.info("Listening at {s}/{d}", .{ address, port });
+    try server.listen(); // blocks
+}
+
+/// Endpoint to write all state transition metrics to the server.
+fn getMetrics(_: *MetricsHandler, _: *httpz.Request, res: *httpz.Response) !void {
+    res.content_type = .TEXT;
+    const writer = res.writer();
+    try state_transition.metrics.write(writer);
+}
+
+fn eraReader(allocator: std.mem.Allocator, era_path: []const u8) !era.Reader {
+    std.debug.print("Reading era file at {s}\n", .{era_path});
+    return try era.Reader.open(allocator, c.mainnet.config, era_path);
+}
+
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
+
+    _ = try std.Thread.spawn(.{}, serveMetrics, .{ allocator, 8008 });
+
+    try state_transition.metrics.init(allocator, .{});
+    defer state_transition.metrics.state_transition.deinit();
+
+    const era_path_state = try std.fs.path.join(
+        allocator,
+        &[_][]const u8{ download_era_options.era_out_dir, download_era_options.era_files[0] },
+    );
+    defer allocator.free(era_path_state);
+    const era_path_blocks = try std.fs.path.join(
+        allocator,
+        &[_][]const u8{ download_era_options.era_out_dir, download_era_options.era_files[1] },
+    );
+    defer allocator.free(era_path_blocks);
+
+    var reader_state = try eraReader(allocator, era_path_state);
+    defer reader_state.close(allocator);
+    var reader_blocks = try eraReader(allocator, era_path_blocks);
+    defer reader_blocks.close(allocator);
+
+    std.debug.print("Reading state\n", .{});
+    var state_ptr = try allocator.create(state_transition.BeaconState);
+    errdefer allocator.destroy(state_ptr);
+    state_ptr.* = try reader_state.readState(allocator, null);
+    const blocks_index = reader_blocks.group_indices[0].blocks_index orelse return error.NoBlockIndex;
+    const index_pubkey_cache = try allocator.create(Index2PubkeyCache);
+    errdefer {
+        index_pubkey_cache.deinit();
+        allocator.destroy(index_pubkey_cache);
+    }
+    index_pubkey_cache.* = Index2PubkeyCache.init(allocator);
+    const pubkey_index_map = try PubkeyIndexMap.init(allocator);
+    errdefer pubkey_index_map.deinit();
+
+    const config = try allocator.create(BeaconConfig);
+    errdefer allocator.destroy(config);
+    config.* = BeaconConfig.init(chain_config, (try state_ptr.genesisValidatorsRoot()).*);
+
+    const immutable_data = state_transition.EpochCacheImmutableData{
+        .config = config,
+        .index_to_pubkey = index_pubkey_cache,
+        .pubkey_to_index = pubkey_index_map,
+    };
+
+    std.debug.print("Creating cached beacon state\n", .{});
+    var cached_state = try CachedBeaconState.createCachedBeaconState(
+        allocator,
+        state_ptr,
+        immutable_data,
+        .{
+            .skip_sync_committee_cache = state_ptr.forkSeq() == .phase0,
+            .skip_sync_pubkeys = false,
+        },
+    );
+    std.debug.print("Running state transition.\nYou may open up a local prometheus instance to check out metrics in action.\n", .{});
+    for (blocks_index.start_slot + 1..blocks_index.start_slot + blocks_index.offsets.len) |slot| {
+        const raw_block = try reader_blocks.readBlock(allocator, slot) orelse continue;
+        defer raw_block.deinit(allocator);
+
+        const block: SignedBlock = .{ .regular = raw_block };
+
+        const block_num = switch (block.message().beaconBlockBody()) {
+            .regular => |b| b.executionPayload().getBlockNumber(),
+            .blinded => |b| b.executionPayloadHeader().getBlockNumber(),
+        };
+        std.debug.print("state slot = {}, block number = {}\n", .{ try cached_state.state.slot(), block_num });
+
+        const next = try state_transition.stateTransition(
+            allocator,
+            cached_state,
+            block,
+            .{
+                .verify_signatures = false,
+                .verify_proposer = false,
+                .verify_state_root = false,
+            },
+        );
+
+        cached_state.deinit();
+        allocator.destroy(cached_state);
+        cached_state = next;
+    }
+}

examples/prometheus.yml

@@ -0,0 +1,7 @@
+# Copied from https://github.com/ChainSafe/lodestar/blob/unstable/prometheus.yml
+scrape_configs:
+  - job_name: beacon
+    scrape_interval: 5s
+    metrics_path: /metrics
+    static_configs:
+      - targets: ["localhost:8008"]