tiny.content.Capacity

1/// The sizes and the work counts a store was built with, carried by a caller2/// from derivation into the store it builds and re-read by every capability to3/// admit a reference. The struct holds the limits it came from, the retained4/// metadata and storage byte counts, and a worst-case work count for a read, a5/// publication, and teardown.6pub const Capacity = struct {7    limits: Limits,8    metadata_bytes: u64,9    storage_bytes: u64,10    read_work: u64,11    publication_work: u64,12    teardown_work: u64,1314    pub const DeriveError: type = CapacityError;1516    /// Turns caller limits into the byte counts and work counts of a store,17    /// called once before a caller lays out storage so it learns how many bytes18    /// the store needs and how much work its operations can cost. The19    /// calculation returns `ObjectLimitEmpty` for a store of no objects,20    /// `TotalByteLimitTooSmall` when the total is below one object,21    /// `TotalByteLimitExceeded` when the total is above the object count times22    /// the bytes per object, and `CapacityArithmeticOverflow` when any of the23    /// products or sums does not fit a `u64`. The function sizes retained24    /// storage as one metadata entry per object, plus the total content bytes,25    /// plus one more object for the staging region. Work counts bound one read26    /// at the object count plus twice the bytes of one object, one publication27    /// at the object count plus six times the bytes of one object, which covers28    /// four hashing passes and two copies, and teardown at one step per object.29    pub fn derive(limits: Limits) DeriveError!Capacity {30        if (limits.objects == 0) return error.ObjectLimitEmpty;31        if (limits.total_bytes < limits.object_bytes) {32            return error.TotalByteLimitTooSmall;33        }34        const possible_total = multiplied(limits.objects, limits.object_bytes);35        if (possible_total < limits.total_bytes) {36            return error.TotalByteLimitExceeded;37        }38        const metadata_bytes = try multipliedChecked(39            limits.objects,40            @sizeOf(Metadata),41        );42        const staged_storage = try added(metadata_bytes, limits.total_bytes);43        const storage_bytes = try added(staged_storage, limits.object_bytes);44        const read_bytes = try multipliedChecked(limits.object_bytes, 2);45        const read_work = try added(limits.objects, read_bytes);46        const publication_hash_passes: u8 = 4;47        const publication_copy_passes: u8 = 2;48        const publication_byte_passes = publication_hash_passes +49            publication_copy_passes;50        const publication_bytes = try multipliedChecked(51            limits.object_bytes,52            publication_byte_passes,53        );54        const publication_work = try added(limits.objects, publication_bytes);55        return .{56            .limits = limits,57            .metadata_bytes = metadata_bytes,58            .storage_bytes = storage_bytes,59            .read_work = read_work,60            .publication_work = publication_work,61            .teardown_work = limits.objects,62        };63    }6465    /// Checks one reference against the store's per-object byte limit, called66    /// first by both capabilities so a reference that is too large for the67    /// store never reaches the provider. The check returns68    /// `ContentExtentExceeded` when the reference's extent is above that limit.69    pub fn validateReference(70        self: Capacity,71        reference: Reference,72    ) ReferenceError!void {73        if (reference.extent.bytes > self.limits.object_bytes) {74            return error.ContentExtentExceeded;75        }76    }77};

1pub const Capacity = model.Capacity;