test: add benchmark that runs a given block range (#675)

Author: MegaRedHand

bench/block_processing.exs

@@ -6,12 +6,15 @@ alias LambdaEthereumConsensus.Store.BlockStore
 alias LambdaEthereumConsensus.Store.StateStore
 alias Types.{BeaconState, SignedBeaconBlock}
 
-{:ok, _} = Store.Db.start_link(nil)
-{:ok, _} = Store.Blocks.start_link(nil)
+Logger.configure(level: :warning)
+
+{:ok, _} = Store.Db.start_link([])
+{:ok, _} = Store.Blocks.start_link([])
+{:ok, _} = Store.BlockStates.start_link([])
 Cache.initialize_cache()
 
 # NOTE: this slot must be at the beginning of an epoch (i.e. a multiple of 32)
-slot = 8_210_240
+slot = 4_213_280
 
 IO.puts("fetching blocks...")
 {:ok, %BeaconState{} = state} = StateStore.get_state_by_slot(slot)

bench/multiple_blocks_processing.exs

@@ -0,0 +1,63 @@
+alias LambdaEthereumConsensus.ForkChoice
+alias LambdaEthereumConsensus.ForkChoice.Handlers
+alias LambdaEthereumConsensus.StateTransition.Cache
+alias LambdaEthereumConsensus.Store
+alias LambdaEthereumConsensus.Store.BlockStore
+alias LambdaEthereumConsensus.Store.StateStore
+alias Types.{BeaconState, SignedBeaconBlock}
+
+Logger.configure(level: :warning)
+
+{:ok, _} = Store.Db.start_link([])
+{:ok, _} = Store.Blocks.start_link([])
+{:ok, _} = Store.BlockStates.start_link([])
+Cache.initialize_cache()
+
+# NOTE: this slot must be at the beginning of an epoch (i.e. a multiple of 32)
+start_slot = 4_213_280
+count = 10
+end_slot = start_slot + count
+
+IO.puts("fetching blocks...")
+{:ok, %BeaconState{} = state} = StateStore.get_state_by_slot(start_slot)
+{:ok, %SignedBeaconBlock{} = signed_block} = BlockStore.get_block_by_slot(state.slot)
+
+blocks =
+  (start_slot + 1)..end_slot
+  # NOTE: we have to consider empty slots
+  |> Enum.flat_map(fn slot ->
+    case BlockStore.get_block_by_slot(slot) do
+      {:ok, block} -> [block]
+      :not_found -> []
+    end
+  end)
+
+IO.puts("initializing store...")
+{:ok, store} = Types.Store.get_forkchoice_store(state, signed_block)
+store = Handlers.on_tick(store, :os.system_time(:second))
+
+IO.puts("Running slots from #{start_slot} to #{end_slot}")
+
+start_time = System.monotonic_time(:millisecond)
+
+Enum.reduce(blocks, store, fn block, store ->
+  start_time = System.monotonic_time(:millisecond)
+  {:ok, new_store} = Handlers.on_block(store, block)
+
+  # process block attestations
+  {:ok, new_store} =
+    signed_block.message.body.attestations
+    |> ForkChoice.apply_handler(new_store, &Handlers.on_attestation(&1, &2, true))
+
+  # process block attester slashings
+  {:ok, new_store} =
+    signed_block.message.body.attester_slashings
+    |> ForkChoice.apply_handler(new_store, &Handlers.on_attester_slashing/2)
+
+  end_time = System.monotonic_time(:millisecond)
+  IO.puts("Slot #{block.message.slot} took #{end_time - start_time} ms")
+  new_store
+end)
+
+end_time = System.monotonic_time(:millisecond)
+IO.puts("Total: took #{end_time - start_time} ms")

lib/lambda_ethereum_consensus/store/lru_cache.ex

@@ -34,7 +34,7 @@ defmodule LambdaEthereumConsensus.Store.LRUCache do
   @spec put(atom(), key(), value()) :: :ok
   def put(table, key, value) do
     cache_value(table, key, value)
-    GenServer.cast(__MODULE__, {:put, key, value})
+    GenServer.cast(table, {:put, key, value})
   end
 
   @spec get(atom(), key(), (key() -> value() | nil)) :: value() | nil
@@ -93,7 +93,7 @@ defmodule LambdaEthereumConsensus.Store.LRUCache do
         cache_miss(table, key, fetch_func)
 
       v ->
-        GenServer.cast(__MODULE__, {:touch_entry, key})
+        :ok = GenServer.cast(table, {:touch_entry, key})
         v
     end
   end
@@ -107,7 +107,7 @@ defmodule LambdaEthereumConsensus.Store.LRUCache do
 
   defp cache_value(table, key, value) do
     :ets.insert_new(table, {key, value, nil})
-    GenServer.cast(__MODULE__, {:touch_entry, key})
+    GenServer.cast(table, {:touch_entry, key})
     value
   end
 

test/integration/fork_choice/handlers_test.exs

@@ -2,15 +2,21 @@ defmodule Integration.ForkChoice.HandlersTest do
   use ExUnit.Case
 
   alias LambdaEthereumConsensus.ForkChoice.Handlers
+  alias LambdaEthereumConsensus.StateTransition.Cache
+  alias LambdaEthereumConsensus.Store.Blocks
   alias LambdaEthereumConsensus.Store.BlockStore
   alias LambdaEthereumConsensus.Store.Db
   alias LambdaEthereumConsensus.Store.StateStore
 
   setup_all do
     start_supervised!(Db)
+    start_supervised!(Blocks)
+    start_supervised!(BlockStates)
+    Cache.initialize_cache()
     :ok
   end
 
+  # TODO: refactor to use randomized fixtures
   @tag :skip
   test "on_block w/data from DB" do
     # NOTE: this test requires a DB with a state, and blocks for the state's slot and the next slot.
@@ -20,7 +26,7 @@ defmodule Integration.ForkChoice.HandlersTest do
     {:ok, signed_block} = BlockStore.get_block_by_slot(state.slot)
     {:ok, new_signed_block} = BlockStore.get_block_by_slot(state.slot + 1)
 
-    assert {:ok, store} = Types.Store.get_forkchoice_store(state, signed_block.message)
+    assert {:ok, store} = Types.Store.get_forkchoice_store(state, signed_block)
     new_store = Handlers.on_tick(store, :os.system_time(:second))
 
     assert {:ok, _} = Handlers.on_block(new_store, new_signed_block)