merge conflicts

Author: spiral-ladder

src/state_transition/cache/effective_balance_increments.zig

@@ -2,9 +2,6 @@ const std = @import("std");
 const Allocator = std.mem.Allocator;
 const preset = @import("preset").preset;
 const AnyBeaconState = @import("fork_types").AnyBeaconState;
-const ReferenceCount = @import("../utils/reference_count.zig").ReferenceCount;
-const BeaconStateAllForks = @import("../types/beacon_state.zig").BeaconStateAllForks;
-const EFFECTIVE_BALANCE_INCREMENT = preset.EFFECTIVE_BALANCE_INCREMENT;
 const RefCount = @import("../utils/ref_count.zig").RefCount;
 
 pub const EffectiveBalanceIncrements = std.ArrayList(u16);

src/state_transition/cache/epoch_cache.zig

@@ -49,8 +49,6 @@ const ForkTypes = @import("fork_types").ForkTypes;
 
 const syncPubkeys = @import("./pubkey_cache.zig").syncPubkeys;
 
-const RefCount = @import("../utils/ref_count.zig").RefCount;
-
 pub const EpochCacheImmutableData = struct {
     config: *const BeaconConfig,
     pubkey_to_index: *PubkeyIndexMap,
@@ -66,10 +64,6 @@ const proposer_weight: f64 = @floatFromInt(c.PROPOSER_WEIGHT);
 const weight_denominator: f64 = @floatFromInt(c.WEIGHT_DENOMINATOR);
 
 pub const proposer_weight_factor: f64 = proposer_weight / (weight_denominator - proposer_weight);
-/// an EpochCache is shared by multiple CachedBeaconStateAllForks instances
-/// a CachedBeaconStateAllForks should increase the reference count of EpochCache when it is created
-/// and decrease the reference count when it is deinitialized
-pub const EpochCacheRc = ReferenceCount(*EpochCache);
 
 pub const EpochCache = struct {
     allocator: Allocator,

src/state_transition/cache/sync_committee_cache.zig

@@ -11,13 +11,12 @@ const SyncCommitteeIndices = std.ArrayList(u32);
 const SyncComitteeValidatorIndexMap = std.AutoHashMap(ValidatorIndex, SyncCommitteeIndices);
 const RefCount = @import("../utils/ref_count.zig").RefCount;
 
-pub const SyncCommitteeCacheRc = ReferenceCount(SyncCommitteeCacheAllForks);
-pub const SyncCommitteeCacheRc = RefCount(SyncCommitteeCacheAllForks);
+pub const SyncCommitteeCacheRc = RefCount(SyncCommitteeCache);
 
 /// EpochCache is the only consumer of this cache but an instance of SyncCommitteeCacheAllForks is shared across EpochCache instances
 /// no EpochCache instance takes the ownership of SyncCommitteeCacheAllForks instance
-/// instead of that, we count on reference counting to deallocate the memory, see ReferenceCount() utility
-pub const SyncCommitteeCacheAllForks = union(enum) {
+/// instead of that, we count on reference counting to deallocate the memory, see RefCount() utility
+pub const SyncCommitteeCache = union(enum) {
     phase0: void,
     altair: *SyncCommitteeCacheAltair,
 

src/state_transition/utils/epoch_shuffling.zig

@@ -11,8 +11,6 @@ const Epoch = types.primitive.Epoch.Type;
 const computeStartSlotAtEpoch = @import("./epoch.zig").computeStartSlotAtEpoch;
 const getBlockRootAtSlot = @import("./block_root.zig").getBlockRootAtSlot;
 const computeAnchorCheckpoint = @import("./anchor_checkpoint.zig").computeAnchorCheckpoint;
-const Epoch = ssz.primitive.Epoch.Type;
-const ReferenceCount = @import("./reference_count.zig").ReferenceCount;
 const RefCount = @import("./ref_count.zig").RefCount;
 
 pub const EpochShufflingRc = RefCount(*EpochShuffling);

src/state_transition/utils/ref_count.zig

@@ -19,20 +19,18 @@ pub fn RefCount(comptime T: type) type {
             return ptr;
         }
 
-        /// private deinit, consumer should call unref() instead
+        /// private deinit, consumer should call release() instead
         fn deinit(self: *@This()) void {
             self.instance.deinit();
             self.allocator.destroy(self);
         }
 
-        /// caution: this returns a copy of the instance, make sure this does not have copy overhead
-        /// or use pointer type instead
         pub fn get(self: *@This()) T {
             return self.instance;
         }
 
         pub fn ref(self: *@This()) *@This() {
-            _ = self._ref_count.fetchAdd(1, .acquire);
+            _ = self._ref_count.fetchAdd(1, .monotonic);
             return self;
         }