Implement Allocative for the protocol views. (#4687)

## Motivation

Tracking the size of the objects being used is important for considering
the memory usage and resolving the OOM.

## Proposal

The `Allocative` trait is implemented for the views, and the code is
followed from there.

Several design decisions were made:
* For the Weighted distribution, the entries are dropped.
* In the views, the context is not taken into account of memory usage.
* For the keys of Ed25519, Secp256k1, EvmSecp256k1, the sizes are
written explicitly.

## Test Plan

The CI.

Adding in `process_confirmed_block` the following 
```rust
tracing::info!("process_confirmed_block, size_of_unique={}", allocative::size_of_unique(&self.chain));
```

works as expected. How to implement more systematically is open to
discussion.

## Release Plan

The goal is to add it to the TestNet Conway.

## Links

None.

Author: MathieuDutSik

Cargo.lock

@@ -72,6 +72,7 @@ license = "Apache-2.0"
 edition = "2021"
 
 [workspace.dependencies]
+allocative = "0.3.4"
 alloy = { version = "1.0.5", default-features = false }
 alloy-primitives = { version = "1.1.0", default-features = false, features = [
     "serde",

Cargo.toml

@@ -35,6 +35,7 @@ web = [
 ]
 
 [dependencies]
+allocative.workspace = true
 alloy-primitives.workspace = true
 anyhow.workspace = true
 async-graphql.workspace = true

examples/Cargo.lock

@@ -8,6 +8,7 @@
 use std::ops::RangeInclusive;
 use std::{borrow::Cow, fmt, io, str::FromStr};
 
+use allocative::{Allocative, Visitor};
 #[cfg(with_testing)]
 use alloy_primitives::FixedBytes;
 use alloy_primitives::{Keccak256, B256};
@@ -33,6 +34,12 @@ use crate::{
 #[cfg_attr(with_testing, derive(Default))]
 pub struct CryptoHash(B256);
 
+impl Allocative for CryptoHash {
+    fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>) {
+        visitor.visit_simple_sized::<Self>();
+    }
+}
+
 impl CryptoHash {
     /// Computes a hash.
     pub fn new<'de, T: BcsHashable<'de>>(value: &T) -> Self {

linera-base/Cargo.toml

@@ -11,6 +11,7 @@ mod secp256k1;
 pub mod signer;
 use std::{fmt::Display, io, num::ParseIntError, str::FromStr};
 
+use allocative::Allocative;
 use alloy_primitives::FixedBytes;
 use custom_debug_derive::Debug;
 pub use ed25519::{Ed25519PublicKey, Ed25519SecretKey, Ed25519Signature};
@@ -24,7 +25,7 @@ use serde::{Deserialize, Serialize};
 pub use signer::*;
 use thiserror::Error;
 
-use crate::{hex_debug, identifiers::AccountOwner};
+use crate::{hex_debug, identifiers::AccountOwner, visit_allocative_simple};
 
 /// The public key of a validator.
 pub type ValidatorPublicKey = secp256k1::Secp256k1PublicKey;
@@ -63,14 +64,15 @@ pub enum SignatureScheme {
     WitType,
     WitLoad,
     WitStore,
+    Allocative,
 )]
 pub enum AccountPublicKey {
     /// Ed25519 public key.
-    Ed25519(ed25519::Ed25519PublicKey),
+    Ed25519(#[allocative(visit = visit_allocative_simple)] ed25519::Ed25519PublicKey),
     /// secp256k1 public key.
-    Secp256k1(secp256k1::Secp256k1PublicKey),
+    Secp256k1(#[allocative(visit = visit_allocative_simple)] secp256k1::Secp256k1PublicKey),
     /// EVM secp256k1 public key.
-    EvmSecp256k1(secp256k1::evm::EvmPublicKey),
+    EvmSecp256k1(#[allocative(visit = visit_allocative_simple)] secp256k1::evm::EvmPublicKey),
 }
 
 /// The private key of a chain owner.
@@ -85,28 +87,34 @@ pub enum AccountSecretKey {
 }
 
 /// The signature of a chain owner.
-#[derive(Eq, PartialEq, Copy, Clone, Debug, Serialize, Deserialize)]
+#[derive(Eq, PartialEq, Copy, Clone, Debug, Serialize, Deserialize, Allocative)]
 pub enum AccountSignature {
     /// Ed25519 signature.
     Ed25519 {
         /// Signature of the value.
+        #[allocative(visit = visit_allocative_simple)]
         signature: ed25519::Ed25519Signature,
         /// Public key of the signer.
+        #[allocative(visit = visit_allocative_simple)]
         public_key: ed25519::Ed25519PublicKey,
     },
     /// secp256k1 signature.
     Secp256k1 {
         /// Signature of the value.
+        #[allocative(visit = visit_allocative_simple)]
         signature: secp256k1::Secp256k1Signature,
         /// Public key of the signer.
+        #[allocative(visit = visit_allocative_simple)]
         public_key: secp256k1::Secp256k1PublicKey,
     },
     /// EVM secp256k1 signature.
     EvmSecp256k1 {
         /// Signature of the value.
+        #[allocative(visit = visit_allocative_simple)]
         signature: secp256k1::evm::EvmSignature,
         /// EVM address of the signer.
         #[debug(with = "hex_debug")]
+        #[allocative(visit = visit_allocative_simple)]
         address: [u8; 20],
     },
 }

linera-base/src/crypto/hash.rs

@@ -13,6 +13,7 @@ use std::{
     str::FromStr,
 };
 
+use allocative::{Allocative, Visitor};
 use k256::{
     ecdsa::{Signature, SigningKey, VerifyingKey},
     elliptic_curve::sec1::FromEncodedPoint,
@@ -44,6 +45,12 @@ pub struct Secp256k1SecretKey(pub SigningKey);
 #[derive(Eq, PartialEq, Ord, PartialOrd, Copy, Clone)]
 pub struct Secp256k1PublicKey(pub VerifyingKey);
 
+impl Allocative for Secp256k1PublicKey {
+    fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>) {
+        visitor.visit_simple_sized::<Self>();
+    }
+}
+
 impl Hash for Secp256k1PublicKey {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.0.to_encoded_point(true).as_bytes().hash(state);
@@ -63,6 +70,12 @@ pub struct Secp256k1KeyPair {
 #[derive(Eq, PartialEq, Copy, Clone)]
 pub struct Secp256k1Signature(pub Signature);
 
+impl Allocative for Secp256k1Signature {
+    fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>) {
+        visitor.visit_simple_sized::<Self>();
+    }
+}
+
 impl Secp256k1PublicKey {
     /// A fake public key used for testing.
     #[cfg(all(with_testing, not(target_arch = "wasm32")))]