diff options
Diffstat (limited to 'src/zenstore')
24 files changed, 174 insertions, 170 deletions
diff --git a/src/zenstore/blockstore.cpp b/src/zenstore/blockstore.cpp index 7df9117db..8a196db33 100644 --- a/src/zenstore/blockstore.cpp +++ b/src/zenstore/blockstore.cpp @@ -578,7 +578,7 @@ BlockStore::WriteChunk(const void* Data, uint64_t Size, uint32_t Alignment, cons } void -BlockStore::WriteChunks(std::span<IoBuffer> Datas, uint32_t Alignment, const WriteChunksCallback& Callback) +BlockStore::WriteChunks(eastl::span<IoBuffer> Datas, uint32_t Alignment, const WriteChunksCallback& Callback) { ZEN_MEMSCOPE(GetBlocksTag()); ZEN_TRACE_CPU("BlockStore::WriteChunks"); @@ -721,8 +721,8 @@ BlockStore::Flush(bool ForceNewBlock) } bool -BlockStore::IterateBlock(std::span<const BlockStoreLocation> ChunkLocations, - std::span<const size_t> InChunkIndexes, +BlockStore::IterateBlock(eastl::span<const BlockStoreLocation> ChunkLocations, + eastl::span<const size_t> InChunkIndexes, const IterateChunksSmallSizeCallback& SmallSizeCallback, const IterateChunksLargeSizeCallback& LargeSizeCallback, uint64_t LargeSizeLimit) @@ -752,10 +752,10 @@ BlockStore::IterateBlock(std::span<const BlockStoreLocation> ChunkLocations, return ChunkLocations[IndexA].Offset < ChunkLocations[IndexB].Offset; }); - auto GetNextRange = [LargeSizeLimit, - IterateSmallChunkWindowSize, - IterateSmallChunkMaxGapSize, - &ChunkLocations](uint64_t BlockFileSize, std::span<const size_t> ChunkIndexes, size_t StartIndexOffset) -> size_t { + auto GetNextRange = [LargeSizeLimit, IterateSmallChunkWindowSize, IterateSmallChunkMaxGapSize, &ChunkLocations]( + uint64_t BlockFileSize, + eastl::span<const size_t> ChunkIndexes, + size_t StartIndexOffset) -> size_t { size_t ChunkCount = 0; size_t StartIndex = ChunkIndexes[StartIndexOffset]; const BlockStoreLocation& StartLocation = ChunkLocations[StartIndex]; @@ -882,7 +882,7 @@ BlockStore::IterateBlock(std::span<const BlockStoreLocation> ChunkLocations, } bool -BlockStore::IterateChunks(const std::span<const BlockStoreLocation>& ChunkLocations, const IterateChunksCallback& Callback) +BlockStore::IterateChunks(const eastl::span<const BlockStoreLocation>& ChunkLocations, const IterateChunksCallback& Callback) { ZEN_MEMSCOPE(GetBlocksTag()); ZEN_TRACE_CPU("BlockStore::IterateChunks"); @@ -903,9 +903,9 @@ BlockStore::IterateChunks(const std::span<const BlockStoreLocation>& ChunkLocati std::sort(ChunkOrder.begin(), ChunkOrder.end(), [&ChunkLocations](const size_t Lhs, const size_t Rhs) { return ChunkLocations[Lhs].BlockIndex < ChunkLocations[Rhs].BlockIndex; }); - size_t RangeStart = 0; - size_t RangeEnd = 0; - const std::span<size_t> ChunkIndexRange(ChunkOrder); + size_t RangeStart = 0; + size_t RangeEnd = 0; + const eastl::span<size_t> ChunkIndexRange(ChunkOrder); while (RangeStart < ChunkOrder.size()) { const size_t ChunkIndex = ChunkOrder[RangeStart]; @@ -1461,7 +1461,7 @@ TEST_CASE("blockstore.multichunks") BlockStoreLocation Locations[5]; size_t ChunkOffset = 0; - Store.WriteChunks(MultiChunkData, 4, [&](std::span<BlockStoreLocation> InLocations) { + Store.WriteChunks(MultiChunkData, 4, [&](eastl::span<BlockStoreLocation> InLocations) { for (const BlockStoreLocation& Location : InLocations) { Locations[ChunkOffset++] = Location; @@ -1484,7 +1484,7 @@ TEST_CASE("blockstore.multichunks") "ABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJ_93"; MultiChunkData.push_back(IoBuffer(IoBuffer::Wrap, FifthChunkData.data(), FifthChunkData.size())); - Store.WriteChunks(MultiChunkData, 4, [&](std::span<BlockStoreLocation> InLocations) { + Store.WriteChunks(MultiChunkData, 4, [&](eastl::span<BlockStoreLocation> InLocations) { for (const BlockStoreLocation& Location : InLocations) { CHECK(ChunkOffset < 5); @@ -1595,7 +1595,7 @@ TEST_CASE("blockstore.iterate.chunks") BadLocationOutOfRange, BadBlockIndex}; Latch WorkLatch(1); - Store.IterateChunks(Locations, [&](uint32_t, std::span<const size_t> ChunkIndexes) -> bool { + Store.IterateChunks(Locations, [&](uint32_t, eastl::span<const size_t> ChunkIndexes) -> bool { WorkLatch.AddCount(1); WorkerPool.ScheduleWork([&, ChunkIndexes = eastl::vector<size_t>(ChunkIndexes.begin(), ChunkIndexes.end())]() { auto _ = MakeGuard([&WorkLatch]() { WorkLatch.CountDown(); }); diff --git a/src/zenstore/cache/cachedisklayer.cpp b/src/zenstore/cache/cachedisklayer.cpp index 2f648bc2d..bbd38d737 100644 --- a/src/zenstore/cache/cachedisklayer.cpp +++ b/src/zenstore/cache/cachedisklayer.cpp @@ -1266,7 +1266,7 @@ ZenCacheDiskLayer::CacheBucket::EndPutBatch(PutBatchHandle* Batch) noexcept } size_t IndexOffset = 0; - m_BlockStore.WriteChunks(Batch->Buffers, m_Configuration.PayloadAlignment, [&](std::span<BlockStoreLocation> Locations) { + m_BlockStore.WriteChunks(Batch->Buffers, m_Configuration.PayloadAlignment, [&](eastl::span<BlockStoreLocation> Locations) { ZEN_MEMSCOPE(GetCacheDiskTag()); eastl::vector<DiskIndexEntry> DiskEntries; { @@ -1527,12 +1527,12 @@ ZenCacheDiskLayer::CacheBucket::EndGetBatch(GetBatchHandle* Batch) noexcept { ZEN_TRACE_CPU("Z$::Bucket::EndGetBatch::ReadInline"); m_BlockStore.IterateChunks( - std::span{begin(InlineBlockLocations), end(InlineBlockLocations)}, - [&](uint32_t, std::span<const size_t> ChunkIndexes) -> bool { + eastl::span{begin(InlineBlockLocations), end(InlineBlockLocations)}, + [&](uint32_t, eastl::span<const size_t> ChunkIndexes) -> bool { // Only read into memory the IoBuffers we could potentially add to memcache const uint64_t LargeChunkSizeLimit = Max(m_Configuration.MemCacheSizeThreshold, 1u * 1024u); m_BlockStore.IterateBlock( - std::span{begin(InlineBlockLocations), end(InlineBlockLocations)}, + eastl::span{begin(InlineBlockLocations), end(InlineBlockLocations)}, ChunkIndexes, [this, &FillOne, &InlineDiskLocations, &InlineKeyIndexes](size_t ChunkIndex, const void* Data, @@ -1798,7 +1798,7 @@ ZenCacheDiskLayer::CacheBucket::Get(const IoHash& HashKey, ZenCacheValue& OutVal void ZenCacheDiskLayer::CacheBucket::Put(const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle) { ZEN_TRACE_CPU("Z$::Bucket::Put"); @@ -2236,7 +2236,7 @@ ZenCacheDiskLayer::CacheBucket::ScrubStorage(ScrubContext& Ctx) return true; }; - m_BlockStore.IterateChunks(ChunkLocations, [&](uint32_t, std::span<const size_t> ChunkIndexes) { + m_BlockStore.IterateChunks(ChunkLocations, [&](uint32_t, eastl::span<const size_t> ChunkIndexes) { return m_BlockStore.IterateBlock(ChunkLocations, ChunkIndexes, ValidateSmallChunk, ValidateLargeChunk, 0); }); } @@ -2404,7 +2404,7 @@ ZenCacheDiskLayer::CacheBucket::EnumerateBucketContents( } void -ZenCacheDiskLayer::CacheBucket::PutStandaloneCacheValue(const IoHash& HashKey, const ZenCacheValue& Value, std::span<IoHash> References) +ZenCacheDiskLayer::CacheBucket::PutStandaloneCacheValue(const IoHash& HashKey, const ZenCacheValue& Value, eastl::span<IoHash> References) { ZEN_TRACE_CPU("Z$::Bucket::PutStandaloneCacheValue"); @@ -2651,7 +2651,7 @@ ZenCacheDiskLayer::CacheBucket::GetMetaData(RwLock::SharedLockScope&, const Buck void ZenCacheDiskLayer::CacheBucket::PutInlineCacheValue(const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle) { ZEN_TRACE_CPU("Z$::Bucket::PutInlineCacheValue"); @@ -3098,10 +3098,10 @@ ZenCacheDiskLayer::CacheBucket::RemoveExpiredData(GcCtx& Ctx, GcStats& Stats) } bool -ZenCacheDiskLayer::CacheBucket::ReadAttachmentsFromMetaData(uint32_t BlockIndex, - std::span<const IoHash> InlineKeys, - std::span<const std::size_t> ChunkIndexes, - eastl::vector<IoHash>& OutReferences) const +ZenCacheDiskLayer::CacheBucket::ReadAttachmentsFromMetaData(uint32_t BlockIndex, + eastl::span<const IoHash> InlineKeys, + eastl::span<const std::size_t> ChunkIndexes, + eastl::vector<IoHash>& OutReferences) const { ZEN_TRACE_CPU("Z$::Bucket::ReadAttachmentsFromMetaData"); IoBuffer MetaDataPayload = m_BlockStore.GetMetaData(BlockIndex); @@ -3117,7 +3117,7 @@ ZenCacheDiskLayer::CacheBucket::ReadAttachmentsFromMetaData(uint32_t BlockI return GetAttachmentsFromMetaData<IoHash, IoHash>( MetaDataPayload, cache::impl::BlockMetaDataExpectedMagic, - [&](std::span<const IoHash> Keys, std::span<const uint32_t> AttachmentCounts, std::span<const IoHash> Attachments) { + [&](eastl::span<const IoHash> Keys, eastl::span<const uint32_t> AttachmentCounts, eastl::span<const IoHash> Attachments) { auto AttachmentReadIt = Attachments.begin(); OutReferences.resize(OutReferences.size() + Attachments.size()); auto OutReferencesWriteIt = OutReferences.end() - Attachments.size(); @@ -3296,7 +3296,7 @@ ZenCacheDiskLayer::CacheBucket::GetReferences(const LoggerRef& Logger, cache::impl::BlockMetaDataExpectedMagic, Keys, AttachmentCounts, - std::span<const IoHash>(OutReferences) + eastl::span<const IoHash>(OutReferences) .subspan(PrecachedReferencesStart, OutReferences.size() - PrecachedReferencesStart)) .Flatten() .AsIoBuffer(); @@ -3421,7 +3421,7 @@ public: FilterReferences(Ctx, fmt::format("cachebucket [LOCKSTATE] '{}'", m_CacheBucket.m_BucketDir), m_AddedReferences); } - virtual std::span<IoHash> GetUnusedReferences(GcCtx& Ctx, std::span<IoHash> IoCids) override + virtual eastl::span<IoHash> GetUnusedReferences(GcCtx& Ctx, eastl::span<IoHash> IoCids) override { ZEN_TRACE_CPU("Z$::Bucket::GetUnusedReferences"); @@ -3443,9 +3443,9 @@ public: NiceTimeSpanMs(Timer.GetElapsedTimeMs())); }); - std::span<IoHash> UnusedReferences = KeepUnusedReferences(m_PrecachedReferences, IoCids); - UnusedReferences = KeepUnusedReferences(m_AddedReferences, UnusedReferences); - UsedCount = IoCids.size() - UnusedReferences.size(); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(m_PrecachedReferences, IoCids); + UnusedReferences = KeepUnusedReferences(m_AddedReferences, UnusedReferences); + UsedCount = IoCids.size() - UnusedReferences.size(); return UnusedReferences; } @@ -3857,7 +3857,7 @@ void ZenCacheDiskLayer::Put(std::string_view InBucket, const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle) { ZEN_TRACE_CPU("Z$::Put"); diff --git a/src/zenstore/cache/structuredcachestore.cpp b/src/zenstore/cache/structuredcachestore.cpp index 87c95f8a2..d86cbf414 100644 --- a/src/zenstore/cache/structuredcachestore.cpp +++ b/src/zenstore/cache/structuredcachestore.cpp @@ -256,7 +256,7 @@ void ZenCacheNamespace::Put(std::string_view InBucket, const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle) { ZEN_TRACE_CPU(OptionalBatchHandle ? "Z$::Namespace::Put(Batched)" : "Z$::Namespace::Put"); @@ -722,7 +722,7 @@ ZenCacheStore::Put(const CacheRequestContext& Context, std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatch* OptionalBatchHandle) { // Ad hoc rejection of known bad usage patterns for DDC bucket names @@ -1230,7 +1230,7 @@ public: FilterReferences(Ctx, fmt::format("cachestore [LOCKSTATE] '{}'", "cachestore"), m_References); } - virtual std::span<IoHash> GetUnusedReferences(GcCtx& Ctx, std::span<IoHash> IoCids) override + virtual eastl::span<IoHash> GetUnusedReferences(GcCtx& Ctx, eastl::span<IoHash> IoCids) override { ZEN_TRACE_CPU("Z$::GetUnusedReferences"); @@ -1252,8 +1252,8 @@ public: NiceTimeSpanMs(Timer.GetElapsedTimeMs())); }); - std::span<IoHash> UnusedReferences = KeepUnusedReferences(m_References, IoCids); - UsedCount = IoCids.size() - UnusedReferences.size(); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(m_References, IoCids); + UsedCount = IoCids.size() - UnusedReferences.size(); return UnusedReferences; } @@ -1307,7 +1307,7 @@ namespace testutils { std::pair<Oid, IoBuffer> CreateBinaryBlob(size_t Size) { return {Oid::NewOid(), CreateRandomBlob(Size)}; } - eastl::vector<std::pair<Oid, CompressedBuffer>> CreateCompressedAttachment(CidStore& Store, const std::span<const size_t>& Sizes) + eastl::vector<std::pair<Oid, CompressedBuffer>> CreateCompressedAttachment(CidStore& Store, const eastl::span<const size_t>& Sizes) { eastl::vector<std::pair<Oid, CompressedBuffer>> Result; Result.reserve(Sizes.size()); @@ -1321,7 +1321,7 @@ namespace testutils { return Result; } - std::pair<IoHash, IoBuffer> CreateRecord(std::span<std::pair<Oid, CompressedBuffer>> Attachments) + std::pair<IoHash, IoBuffer> CreateRecord(eastl::span<std::pair<Oid, CompressedBuffer>> Attachments) { Oid Id = Oid::NewOid(); IoHash Key = ToIoHash(Id); @@ -2103,27 +2103,29 @@ TEST_CASE("cachestore.newgc.basics") std::unordered_map<IoHash, CacheEntry> CacheEntries; - auto CreateCacheRecord = - [&](ZenCacheNamespace& Zcs, CidStore& CidStore, std::string_view Bucket, std::span<std::pair<Oid, CompressedBuffer>> Attachments) { - eastl::vector<IoHash> AttachmentKeys; - for (const auto& Attachment : Attachments) - { - AttachmentKeys.push_back(Attachment.second.DecodeRawHash()); - } - auto Record = CreateRecord(Attachments); - Zcs.Put(Bucket, - Record.first, - {.Value = Record.second, - .RawSize = Record.second.GetSize(), - .RawHash = IoHash::HashBuffer(Record.second.GetData(), Record.second.GetSize())}, - AttachmentKeys); - for (const auto& Attachment : Attachments) - { - CidStore.AddChunk(Attachment.second.GetCompressed().Flatten().AsIoBuffer(), Attachment.second.DecodeRawHash()); - } - CacheEntries.insert({Record.first, CacheEntry{.Data = Record.second, .Attachments = {Attachments.begin(), Attachments.end()}}}); - return Record.first; - }; + auto CreateCacheRecord = [&](ZenCacheNamespace& Zcs, + CidStore& CidStore, + std::string_view Bucket, + eastl::span<std::pair<Oid, CompressedBuffer>> Attachments) { + eastl::vector<IoHash> AttachmentKeys; + for (const auto& Attachment : Attachments) + { + AttachmentKeys.push_back(Attachment.second.DecodeRawHash()); + } + auto Record = CreateRecord(Attachments); + Zcs.Put(Bucket, + Record.first, + {.Value = Record.second, + .RawSize = Record.second.GetSize(), + .RawHash = IoHash::HashBuffer(Record.second.GetData(), Record.second.GetSize())}, + AttachmentKeys); + for (const auto& Attachment : Attachments) + { + CidStore.AddChunk(Attachment.second.GetCompressed().Flatten().AsIoBuffer(), Attachment.second.DecodeRawHash()); + } + CacheEntries.insert({Record.first, CacheEntry{.Data = Record.second, .Attachments = {Attachments.begin(), Attachments.end()}}}); + return Record.first; + }; auto CreateCacheValue = [&](ZenCacheNamespace& Zcs, std::string_view Bucket, size_t Size) { std::pair<Oid, IoBuffer> CacheValue = CreateBinaryBlob(Size); IoHash Key = ToIoHash(CacheValue.first); diff --git a/src/zenstore/cas.cpp b/src/zenstore/cas.cpp index e85383a2a..ce1ebe231 100644 --- a/src/zenstore/cas.cpp +++ b/src/zenstore/cas.cpp @@ -62,13 +62,13 @@ public: virtual void Initialize(const CidStoreConfiguration& InConfig) override; virtual CasStore::InsertResult InsertChunk(IoBuffer Chunk, const IoHash& ChunkHash, InsertMode Mode) override; - virtual eastl::vector<InsertResult> InsertChunks(std::span<IoBuffer> Data, - std::span<IoHash> ChunkHashes, - InsertMode Mode = InsertMode::kMayBeMovedInPlace) override; + virtual eastl::vector<InsertResult> InsertChunks(eastl::span<IoBuffer> Data, + eastl::span<IoHash> ChunkHashes, + InsertMode Mode = InsertMode::kMayBeMovedInPlace) override; virtual IoBuffer FindChunk(const IoHash& ChunkHash) override; virtual bool ContainsChunk(const IoHash& ChunkHash) override; virtual void FilterChunks(HashKeySet& InOutChunks) override; - virtual bool IterateChunks(std::span<IoHash> DecompressedIds, + virtual bool IterateChunks(eastl::span<IoHash> DecompressedIds, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit) override; @@ -260,9 +260,9 @@ CasImpl::InsertChunk(IoBuffer Chunk, const IoHash& ChunkHash, InsertMode Mode) static void GetCompactCasResults(CasContainerStrategy& Strategy, - std::span<IoBuffer> Data, - std::span<IoHash> ChunkHashes, - std::span<size_t> Indexes, + eastl::span<IoBuffer> Data, + eastl::span<IoHash> ChunkHashes, + eastl::span<size_t> Indexes, eastl::vector<CasStore::InsertResult> Results) { const size_t Count = Indexes.size(); @@ -294,9 +294,9 @@ GetCompactCasResults(CasContainerStrategy& Strategy, static void GetFileCasResults(FileCasStrategy& Strategy, CasStore::InsertMode Mode, - std::span<IoBuffer> Data, - std::span<IoHash> ChunkHashes, - std::span<size_t> Indexes, + eastl::span<IoBuffer> Data, + eastl::span<IoHash> ChunkHashes, + eastl::span<size_t> Indexes, eastl::vector<CasStore::InsertResult> Results) { for (size_t Index : Indexes) @@ -306,7 +306,7 @@ GetFileCasResults(FileCasStrategy& Strategy, }; eastl::vector<CasStore::InsertResult> -CasImpl::InsertChunks(std::span<IoBuffer> Data, std::span<IoHash> ChunkHashes, CasStore::InsertMode Mode) +CasImpl::InsertChunks(eastl::span<IoBuffer> Data, eastl::span<IoHash> ChunkHashes, CasStore::InsertMode Mode) { ZEN_MEMSCOPE(GetCasTag()); ZEN_TRACE_CPU("CAS::InsertChunks"); @@ -406,7 +406,7 @@ CasImpl::FilterChunks(HashKeySet& InOutChunks) } bool -CasImpl::IterateChunks(std::span<IoHash> DecompressedIds, +CasImpl::IterateChunks(eastl::span<IoHash> DecompressedIds, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit) diff --git a/src/zenstore/cas.h b/src/zenstore/cas.h index 5e7085d9b..b771a5657 100644 --- a/src/zenstore/cas.h +++ b/src/zenstore/cas.h @@ -39,13 +39,13 @@ public: virtual void Initialize(const CidStoreConfiguration& Config) = 0; virtual InsertResult InsertChunk(IoBuffer Data, const IoHash& ChunkHash, InsertMode Mode = InsertMode::kMayBeMovedInPlace) = 0; - virtual eastl::vector<InsertResult> InsertChunks(std::span<IoBuffer> Data, - std::span<IoHash> ChunkHashes, - InsertMode Mode = InsertMode::kMayBeMovedInPlace) = 0; + virtual eastl::vector<InsertResult> InsertChunks(eastl::span<IoBuffer> Data, + eastl::span<IoHash> ChunkHashes, + InsertMode Mode = InsertMode::kMayBeMovedInPlace) = 0; virtual IoBuffer FindChunk(const IoHash& ChunkHash) = 0; virtual bool ContainsChunk(const IoHash& ChunkHash) = 0; virtual void FilterChunks(HashKeySet& InOutChunks) = 0; - virtual bool IterateChunks(std::span<IoHash> DecompressedIds, + virtual bool IterateChunks(eastl::span<IoHash> DecompressedIds, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit) = 0; diff --git a/src/zenstore/cidstore.cpp b/src/zenstore/cidstore.cpp index ca505cc7a..b0125ca1e 100644 --- a/src/zenstore/cidstore.cpp +++ b/src/zenstore/cidstore.cpp @@ -45,7 +45,9 @@ struct CidStore::Impl return {.New = Result.New}; } - eastl::vector<CidStore::InsertResult> AddChunks(std::span<IoBuffer> ChunkDatas, std::span<IoHash> RawHashes, CidStore::InsertMode Mode) + eastl::vector<CidStore::InsertResult> AddChunks(eastl::span<IoBuffer> ChunkDatas, + eastl::span<IoHash> RawHashes, + CidStore::InsertMode Mode) { if (ChunkDatas.size() == 1) { @@ -117,7 +119,7 @@ struct CidStore::Impl InOutChunks.RemoveHashesIf([&](const IoHash& Hash) { return ContainsChunk(Hash); }); } - bool IterateChunks(std::span<IoHash> DecompressedIds, + bool IterateChunks(eastl::span<IoHash> DecompressedIds, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit) @@ -198,7 +200,7 @@ CidStore::AddChunk(const IoBuffer& ChunkData, const IoHash& RawHash, InsertMode } eastl::vector<CidStore::InsertResult> -CidStore::AddChunks(std::span<IoBuffer> ChunkDatas, std::span<IoHash> RawHashes, InsertMode Mode) +CidStore::AddChunks(eastl::span<IoBuffer> ChunkDatas, eastl::span<IoHash> RawHashes, InsertMode Mode) { return m_Impl->AddChunks(ChunkDatas, RawHashes, Mode); } @@ -216,7 +218,7 @@ CidStore::ContainsChunk(const IoHash& DecompressedId) } bool -CidStore::IterateChunks(std::span<IoHash> DecompressedIds, +CidStore::IterateChunks(eastl::span<IoHash> DecompressedIds, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit) diff --git a/src/zenstore/compactcas.cpp b/src/zenstore/compactcas.cpp index 2e331ab34..e0ed14e14 100644 --- a/src/zenstore/compactcas.cpp +++ b/src/zenstore/compactcas.cpp @@ -226,7 +226,7 @@ CasContainerStrategy::InsertChunk(IoBuffer Chunk, const IoHash& ChunkHash) } eastl::vector<CasStore::InsertResult> -CasContainerStrategy::InsertChunks(std::span<IoBuffer> Chunks, std::span<IoHash> ChunkHashes) +CasContainerStrategy::InsertChunks(eastl::span<IoBuffer> Chunks, eastl::span<IoHash> ChunkHashes) { ZEN_MEMSCOPE(GetCasContainerTag()); @@ -263,7 +263,7 @@ CasContainerStrategy::InsertChunks(std::span<IoBuffer> Chunks, std::span<IoHash> } size_t ChunkOffset = 0; - m_BlockStore.WriteChunks(Datas, m_PayloadAlignment, [&](std::span<BlockStoreLocation> Locations) { + m_BlockStore.WriteChunks(Datas, m_PayloadAlignment, [&](eastl::span<BlockStoreLocation> Locations) { ZEN_MEMSCOPE(GetCasContainerTag()); eastl::vector<CasDiskIndexEntry> IndexEntries; for (const BlockStoreLocation& Location : Locations) @@ -323,7 +323,7 @@ CasContainerStrategy::FilterChunks(HashKeySet& InOutChunks) } bool -CasContainerStrategy::IterateChunks(std::span<IoHash> ChunkHashes, +CasContainerStrategy::IterateChunks(eastl::span<IoHash> ChunkHashes, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit) @@ -360,7 +360,7 @@ CasContainerStrategy::IterateChunks(std::span<IoHash> ChunkHashes, return true; } - auto DoOneBlock = [&](std::span<const size_t> ChunkIndexes) { + auto DoOneBlock = [&](eastl::span<const size_t> ChunkIndexes) { if (ChunkIndexes.size() < 4) { for (size_t ChunkIndex : ChunkIndexes) @@ -391,7 +391,7 @@ CasContainerStrategy::IterateChunks(std::span<IoHash> ChunkHashes, Latch WorkLatch(1); std::atomic_bool AsyncContinue = true; - bool Continue = m_BlockStore.IterateChunks(FoundChunkLocations, [&](uint32_t BlockIndex, std::span<const size_t> ChunkIndexes) { + bool Continue = m_BlockStore.IterateChunks(FoundChunkLocations, [&](uint32_t BlockIndex, eastl::span<const size_t> ChunkIndexes) { if (OptionalWorkerPool && (ChunkIndexes.size() > 3)) { WorkLatch.AddCount(1); @@ -531,7 +531,7 @@ CasContainerStrategy::ScrubStorage(ScrubContext& Ctx) return true; }; - m_BlockStore.IterateChunks(ChunkLocations, [&](uint32_t, std::span<const size_t> ChunkIndexes) { + m_BlockStore.IterateChunks(ChunkLocations, [&](uint32_t, eastl::span<const size_t> ChunkIndexes) { return m_BlockStore.IterateBlock(ChunkLocations, ChunkIndexes, ValidateSmallChunk, ValidateLargeChunk, 0); }); } @@ -767,9 +767,9 @@ public: NiceTimeSpanMs(Timer.GetElapsedTimeMs())); }); - std::span<IoHash> UnusedCids = GetUnusedReferences(m_Cids); - Stats.CheckedCount = m_Cids.size(); - Stats.FoundCount = UnusedCids.size(); + eastl::span<IoHash> UnusedCids = GetUnusedReferences(m_Cids); + Stats.CheckedCount = m_Cids.size(); + Stats.FoundCount = UnusedCids.size(); if (!Ctx.Settings.CollectSmallObjects) { @@ -1518,7 +1518,7 @@ TEST_CASE("compactcas.threadedinsert") HashKeySet Deleted; GcStats Stats; GcStoreCompactor* Compactor = - Pruner->RemoveUnreferencedData(Ctx, Stats, [&](std::span<IoHash> References) -> std::span<IoHash> { + Pruner->RemoveUnreferencedData(Ctx, Stats, [&](eastl::span<IoHash> References) -> eastl::span<IoHash> { eastl::vector<IoHash> Unreferenced; HashKeySet Retain; Retain.AddHashesToSet(KeepHashes); diff --git a/src/zenstore/compactcas.h b/src/zenstore/compactcas.h index f72a707ca..eea0b2e15 100644 --- a/src/zenstore/compactcas.h +++ b/src/zenstore/compactcas.h @@ -52,11 +52,11 @@ struct CasContainerStrategy final : public GcStorage, public GcReferenceStore ~CasContainerStrategy(); CasStore::InsertResult InsertChunk(IoBuffer Chunk, const IoHash& ChunkHash); - eastl::vector<CasStore::InsertResult> InsertChunks(std::span<IoBuffer> Chunks, std::span<IoHash> ChunkHashes); + eastl::vector<CasStore::InsertResult> InsertChunks(eastl::span<IoBuffer> Chunks, eastl::span<IoHash> ChunkHashes); IoBuffer FindChunk(const IoHash& ChunkHash); bool HaveChunk(const IoHash& ChunkHash); void FilterChunks(HashKeySet& InOutChunks); - bool IterateChunks(std::span<IoHash> ChunkHashes, + bool IterateChunks(eastl::span<IoHash> ChunkHashes, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit); diff --git a/src/zenstore/filecas.cpp b/src/zenstore/filecas.cpp index 36942b515..52e501595 100644 --- a/src/zenstore/filecas.cpp +++ b/src/zenstore/filecas.cpp @@ -615,7 +615,7 @@ FileCasStrategy::FilterChunks(HashKeySet& InOutChunks) } bool -FileCasStrategy::IterateChunks(std::span<IoHash> ChunkHashes, +FileCasStrategy::IterateChunks(eastl::span<IoHash> ChunkHashes, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool) { @@ -1388,9 +1388,9 @@ public: NiceTimeSpanMs(Timer.GetElapsedTimeMs())); }); - std::span<IoHash> UnusedCids = GetUnusedReferences(m_Cids); - Stats.CheckedCount = m_Cids.size(); - Stats.FoundCount = UnusedCids.size(); + eastl::span<IoHash> UnusedCids = GetUnusedReferences(m_Cids); + Stats.CheckedCount = m_Cids.size(); + Stats.FoundCount = UnusedCids.size(); if (UnusedCids.empty()) { // Nothing to collect diff --git a/src/zenstore/filecas.h b/src/zenstore/filecas.h index c3adf125c..0976a4fc3 100644 --- a/src/zenstore/filecas.h +++ b/src/zenstore/filecas.h @@ -39,7 +39,7 @@ struct FileCasStrategy final : public GcStorage, public GcReferenceStore IoBuffer FindChunk(const IoHash& ChunkHash); bool HaveChunk(const IoHash& ChunkHash); void FilterChunks(HashKeySet& InOutChunks); - bool IterateChunks(std::span<IoHash> ChunkHashes, + bool IterateChunks(eastl::span<IoHash> ChunkHashes, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool); void Flush(); diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp index 258ec80ca..b158c97aa 100644 --- a/src/zenstore/gc.cpp +++ b/src/zenstore/gc.cpp @@ -581,8 +581,8 @@ FilterReferences(GcCtx& Ctx, std::string_view Context, eastl::vector<IoHash>& In return true; } -std::span<IoHash> -KeepUnusedReferences(std::span<const IoHash> SortedUsedReferences, std::span<IoHash> SortedReferences) +eastl::span<IoHash> +KeepUnusedReferences(eastl::span<const IoHash> SortedUsedReferences, eastl::span<IoHash> SortedReferences) { if (SortedUsedReferences.empty()) { @@ -1166,8 +1166,8 @@ GcManager::CollectGarbage(const GcSettings& Settings) { ZEN_TRACE_CPU("GcV2::RemoveUnreferencedData"); - const auto GetUnusedReferences = [&ReferenceCheckers, &Ctx](std::span<IoHash> References) -> std::span<IoHash> { - std::span<IoHash> UnusedCids(References); + const auto GetUnusedReferences = [&ReferenceCheckers, &Ctx](eastl::span<IoHash> References) -> eastl::span<IoHash> { + eastl::span<IoHash> UnusedCids(References); ZEN_ASSERT(UnusedCids.empty() || UnusedCids[0] != IoHash::Zero); for (const auto& It : ReferenceCheckers) { @@ -2852,35 +2852,35 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences; eastl::vector<IoHash> References; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.empty()); } { eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; eastl::vector<IoHash> References; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.empty()); } { eastl::vector<IoHash> UsedReferences{}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 5); } { eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.empty()); } { eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[2], Hashes[4]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 2); CHECK(UnusedReferences[0] == Hashes[1]); CHECK(UnusedReferences[1] == Hashes[3]); @@ -2889,7 +2889,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[2], Hashes[3], Hashes[4]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 2); CHECK(UnusedReferences[0] == Hashes[0]); CHECK(UnusedReferences[1] == Hashes[1]); @@ -2898,7 +2898,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 2); CHECK(UnusedReferences[0] == Hashes[3]); CHECK(UnusedReferences[1] == Hashes[4]); @@ -2907,7 +2907,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[0], Hashes[1], Hashes[2], Hashes[4]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 1); CHECK(UnusedReferences[0] == Hashes[3]); } @@ -2915,7 +2915,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[1], Hashes[3]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 3); CHECK(UnusedReferences[0] == Hashes[0]); CHECK(UnusedReferences[1] == Hashes[2]); @@ -2925,7 +2925,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[0]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 4); CHECK(UnusedReferences[0] == Hashes[1]); CHECK(UnusedReferences[1] == Hashes[2]); @@ -2936,7 +2936,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[1]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 4); CHECK(UnusedReferences[0] == Hashes[0]); CHECK(UnusedReferences[1] == Hashes[2]); @@ -2947,7 +2947,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[3]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 4); CHECK(UnusedReferences[0] == Hashes[0]); CHECK(UnusedReferences[1] == Hashes[1]); @@ -2958,7 +2958,7 @@ TEST_CASE("gc.keepunusedreferences") { eastl::vector<IoHash> UsedReferences{Hashes[4]}; eastl::vector<IoHash> References{Hashes[0], Hashes[1], Hashes[2], Hashes[3], Hashes[4]}; - std::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); + eastl::span<IoHash> UnusedReferences = KeepUnusedReferences(UsedReferences, References); CHECK(UnusedReferences.size() == 4); CHECK(UnusedReferences[0] == Hashes[0]); CHECK(UnusedReferences[1] == Hashes[1]); diff --git a/src/zenstore/hashkeyset.cpp b/src/zenstore/hashkeyset.cpp index a5436f5cb..1fa32d25d 100644 --- a/src/zenstore/hashkeyset.cpp +++ b/src/zenstore/hashkeyset.cpp @@ -13,7 +13,7 @@ HashKeySet::AddHashToSet(const IoHash& HashToAdd) } void -HashKeySet::AddHashesToSet(std::span<const IoHash> HashesToAdd) +HashKeySet::AddHashesToSet(eastl::span<const IoHash> HashesToAdd) { m_HashSet.insert(HashesToAdd.begin(), HashesToAdd.end()); } diff --git a/src/zenstore/include/zenstore/blockstore.h b/src/zenstore/include/zenstore/blockstore.h index fe38d40ae..205939faf 100644 --- a/src/zenstore/include/zenstore/blockstore.h +++ b/src/zenstore/include/zenstore/blockstore.h @@ -132,7 +132,7 @@ public: typedef std::function<bool(size_t ChunkIndex, const void* Data, uint64_t Size)> IterateChunksSmallSizeCallback; typedef std::function<bool(size_t ChunkIndex, BlockStoreFile& File, uint64_t Offset, uint64_t Size)> IterateChunksLargeSizeCallback; typedef std::function<void(const BlockStoreLocation& Location)> WriteChunkCallback; - typedef std::function<bool(uint32_t BlockIndex, std::span<const size_t> ChunkIndexes)> IterateChunksCallback; + typedef std::function<bool(uint32_t BlockIndex, eastl::span<const size_t> ChunkIndexes)> IterateChunksCallback; struct BlockUsageInfo { @@ -155,16 +155,16 @@ public: void WriteChunk(const void* Data, uint64_t Size, uint32_t Alignment, const WriteChunkCallback& Callback); - typedef std::function<void(std::span<BlockStoreLocation> Locations)> WriteChunksCallback; - void WriteChunks(std::span<IoBuffer> Datas, uint32_t Alignment, const WriteChunksCallback& Callback); + typedef std::function<void(eastl::span<BlockStoreLocation> Locations)> WriteChunksCallback; + void WriteChunks(eastl::span<IoBuffer> Datas, uint32_t Alignment, const WriteChunksCallback& Callback); IoBuffer TryGetChunk(const BlockStoreLocation& Location) const; void Flush(bool ForceNewBlock); - bool IterateChunks(const std::span<const BlockStoreLocation>& ChunkLocations, const IterateChunksCallback& Callback); + bool IterateChunks(const eastl::span<const BlockStoreLocation>& ChunkLocations, const IterateChunksCallback& Callback); - bool IterateBlock(std::span<const BlockStoreLocation> ChunkLocations, - std::span<const size_t> ChunkIndexes, + bool IterateBlock(eastl::span<const BlockStoreLocation> ChunkLocations, + eastl::span<const size_t> ChunkIndexes, const IterateChunksSmallSizeCallback& SmallSizeCallback, const IterateChunksLargeSizeCallback& LargeSizeCallback, uint64_t LargeSizeLimit); diff --git a/src/zenstore/include/zenstore/cache/cachedisklayer.h b/src/zenstore/include/zenstore/cache/cachedisklayer.h index c5c0ae36e..d350744b0 100644 --- a/src/zenstore/include/zenstore/cache/cachedisklayer.h +++ b/src/zenstore/include/zenstore/cache/cachedisklayer.h @@ -182,7 +182,7 @@ public: void Put(std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle); bool Drop(); bool DropBucket(std::string_view Bucket); @@ -234,11 +234,11 @@ public: struct PutBatchHandle; PutBatchHandle* BeginPutBatch(eastl::vector<bool>& OutResult); void EndPutBatch(PutBatchHandle* Batch) noexcept; - void Put(const IoHash& HashKey, const ZenCacheValue& Value, std::span<IoHash> References, PutBatchHandle* OptionalBatchHandle); - uint64_t MemCacheTrim(GcClock::TimePoint ExpireTime); - bool Drop(); - void Flush(); - void ScrubStorage(ScrubContext& Ctx); + void Put(const IoHash& HashKey, const ZenCacheValue& Value, eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle); + uint64_t MemCacheTrim(GcClock::TimePoint ExpireTime); + bool Drop(); + void Flush(); + void ScrubStorage(ScrubContext& Ctx); RwLock::SharedLockScope GetGcReferencerLock(); struct ReferencesStats @@ -256,10 +256,10 @@ public: eastl::vector<IoHash>& OutReferences, ReferencesStats* OptionalOutReferencesStats); - bool ReadAttachmentsFromMetaData(uint32_t BlockIndex, - std::span<const IoHash> InlineKeys, - std::span<const std::size_t> ChunkIndexes, - eastl::vector<IoHash>& OutReferences) const; + bool ReadAttachmentsFromMetaData(uint32_t BlockIndex, + eastl::span<const IoHash> InlineKeys, + eastl::span<const std::size_t> ChunkIndexes, + eastl::vector<IoHash>& OutReferences) const; inline GcStorageSize StorageSize() const { @@ -381,11 +381,11 @@ public: virtual eastl::vector<GcReferenceValidator*> CreateReferenceValidators(GcCtx& Ctx) override; void BuildPath(PathBuilderBase& Path, const IoHash& HashKey) const; - void PutStandaloneCacheValue(const IoHash& HashKey, const ZenCacheValue& Value, std::span<IoHash> References); + void PutStandaloneCacheValue(const IoHash& HashKey, const ZenCacheValue& Value, eastl::span<IoHash> References); IoBuffer GetStandaloneCacheValue(const DiskLocation& Loc, const IoHash& HashKey) const; void PutInlineCacheValue(const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle = nullptr); IoBuffer GetInlineCacheValue(const DiskLocation& Loc) const; CacheValueDetails::ValueDetails GetValueDetails(RwLock::SharedLockScope&, const IoHash& Key, PayloadIndex Index) const; diff --git a/src/zenstore/include/zenstore/cache/structuredcachestore.h b/src/zenstore/include/zenstore/cache/structuredcachestore.h index faaba407f..7f65e6d12 100644 --- a/src/zenstore/include/zenstore/cache/structuredcachestore.h +++ b/src/zenstore/include/zenstore/cache/structuredcachestore.h @@ -94,7 +94,7 @@ public: void Put(std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatchHandle* OptionalBatchHandle = nullptr); bool DropBucket(std::string_view Bucket); @@ -248,7 +248,7 @@ public: std::string_view Bucket, const IoHash& HashKey, const ZenCacheValue& Value, - std::span<IoHash> References, + eastl::span<IoHash> References, PutBatch* OptionalBatchHandle = nullptr); bool DropBucket(std::string_view Namespace, std::string_view Bucket); diff --git a/src/zenstore/include/zenstore/cache/upstreamcacheclient.h b/src/zenstore/include/zenstore/cache/upstreamcacheclient.h index ee5f93019..9e7c87026 100644 --- a/src/zenstore/include/zenstore/cache/upstreamcacheclient.h +++ b/src/zenstore/include/zenstore/cache/upstreamcacheclient.h @@ -101,17 +101,17 @@ public: virtual bool IsActive() = 0; - virtual void GetCacheValues(std::string_view Namespace, - std::span<CacheValueRequest*> CacheValueRequests, - OnCacheValueGetComplete&& OnComplete) = 0; + virtual void GetCacheValues(std::string_view Namespace, + eastl::span<CacheValueRequest*> CacheValueRequests, + OnCacheValueGetComplete&& OnComplete) = 0; - virtual void GetCacheRecords(std::string_view Namespace, - std::span<CacheKeyRequest*> Requests, - OnCacheRecordGetComplete&& OnComplete) = 0; + virtual void GetCacheRecords(std::string_view Namespace, + eastl::span<CacheKeyRequest*> Requests, + OnCacheRecordGetComplete&& OnComplete) = 0; - virtual void GetCacheChunks(std::string_view Namespace, - std::span<CacheChunkRequest*> CacheChunkRequests, - OnCacheChunksGetComplete&& OnComplete) = 0; + virtual void GetCacheChunks(std::string_view Namespace, + eastl::span<CacheChunkRequest*> CacheChunkRequests, + OnCacheChunksGetComplete&& OnComplete) = 0; virtual void EnqueueUpstream(UpstreamCacheRecord CacheRecord) = 0; }; diff --git a/src/zenstore/include/zenstore/caslog.h b/src/zenstore/include/zenstore/caslog.h index 3d95c9c90..8cd16e34a 100644 --- a/src/zenstore/include/zenstore/caslog.h +++ b/src/zenstore/include/zenstore/caslog.h @@ -85,7 +85,7 @@ public: CasLogFile::Append(&Record, sizeof Record); } - void Append(const std::span<T>& Records) { CasLogFile::Append(Records.data(), sizeof(T) * Records.size()); } + void Append(const eastl::span<T>& Records) { CasLogFile::Append(Records.data(), sizeof(T) * Records.size()); } }; } // namespace zen diff --git a/src/zenstore/include/zenstore/cidstore.h b/src/zenstore/include/zenstore/cidstore.h index ac73d71ea..0bbc175e4 100644 --- a/src/zenstore/include/zenstore/cidstore.h +++ b/src/zenstore/include/zenstore/cidstore.h @@ -76,11 +76,11 @@ public: void Initialize(const CidStoreConfiguration& Config); InsertResult AddChunk(const IoBuffer& ChunkData, const IoHash& RawHash, InsertMode Mode = InsertMode::kMayBeMovedInPlace); - eastl::vector<InsertResult> AddChunks(std::span<IoBuffer> ChunkDatas, - std::span<IoHash> RawHashes, - InsertMode Mode = InsertMode::kMayBeMovedInPlace); + eastl::vector<InsertResult> AddChunks(eastl::span<IoBuffer> ChunkDatas, + eastl::span<IoHash> RawHashes, + InsertMode Mode = InsertMode::kMayBeMovedInPlace); virtual IoBuffer FindChunkByCid(const IoHash& DecompressedId) override; - bool IterateChunks(std::span<IoHash> DecompressedIds, + bool IterateChunks(eastl::span<IoHash> DecompressedIds, const std::function<bool(size_t Index, const IoBuffer& Payload)>& AsyncCallback, WorkerThreadPool* OptionalWorkerPool, uint64_t LargeSizeLimit); diff --git a/src/zenstore/include/zenstore/gc.h b/src/zenstore/include/zenstore/gc.h index f98b0a537..b12ddc76b 100644 --- a/src/zenstore/include/zenstore/gc.h +++ b/src/zenstore/include/zenstore/gc.h @@ -12,13 +12,13 @@ ZEN_THIRD_PARTY_INCLUDES_START #include <fmt/format.h> ZEN_THIRD_PARTY_INCLUDES_END +#include <EASTL/span.h> #include <atomic> #include <chrono> #include <condition_variable> #include <filesystem> #include <functional> #include <optional> -#include <span> #include <thread> ZEN_THIRD_PARTY_INCLUDES_START @@ -228,11 +228,11 @@ public: // Go through IoCids and see which ones are referenced. If it is the reference must be removed from IoCids // This function should use pre-cached information on what is referenced as we are in stop the world mode - virtual std::span<IoHash> GetUnusedReferences(GcCtx& Ctx, std::span<IoHash> IoCids) = 0; + virtual eastl::span<IoHash> GetUnusedReferences(GcCtx& Ctx, eastl::span<IoHash> IoCids) = 0; }; -std::span<IoHash> KeepUnusedReferences(std::span<const IoHash> SortedUsedReferences, std::span<IoHash> SortedReferences); -bool FilterReferences(GcCtx& Ctx, std::string_view Context, eastl::vector<IoHash>& InOutReferences); +eastl::span<IoHash> KeepUnusedReferences(eastl::span<const IoHash> SortedUsedReferences, eastl::span<IoHash> SortedReferences); +bool FilterReferences(GcCtx& Ctx, std::string_view Context, eastl::vector<IoHash>& InOutReferences); /** * @brief An interface to implement a lock for Stop The World (from writing new data) @@ -285,7 +285,7 @@ public: virtual std::string GetGcName(GcCtx& Ctx) = 0; - typedef std::function<std::span<IoHash>(std::span<IoHash> References)> GetUnusedReferencesFunc; + typedef std::function<eastl::span<IoHash>(eastl::span<IoHash> References)> GetUnusedReferencesFunc; // Check a set of references to see if they are in use. // Use the GetUnusedReferences input function to check if references are used and update any pointers diff --git a/src/zenstore/include/zenstore/hashkeyset.h b/src/zenstore/include/zenstore/hashkeyset.h index 411a6256e..70aacd0e2 100644 --- a/src/zenstore/include/zenstore/hashkeyset.h +++ b/src/zenstore/include/zenstore/hashkeyset.h @@ -18,14 +18,14 @@ class HashKeySet { public: void AddHashToSet(const IoHash& HashToAdd); - void AddHashesToSet(std::span<const IoHash> HashesToAdd); + void AddHashesToSet(eastl::span<const IoHash> HashesToAdd); void RemoveHashesIf(std::function<bool(const IoHash& CandidateHash)>&& Predicate); void IterateHashes(std::function<void(const IoHash& Hash)>&& Callback) const; [[nodiscard]] inline bool ContainsHash(const IoHash& Hash) const { return m_HashSet.find(Hash) != m_HashSet.end(); } [[nodiscard]] inline bool IsEmpty() const { return m_HashSet.empty(); } [[nodiscard]] inline size_t GetSize() const { return m_HashSet.size(); } - inline void FilterHashes(std::span<const IoHash> Candidates, Invocable<const IoHash&> auto MatchFunc) const + inline void FilterHashes(eastl::span<const IoHash> Candidates, Invocable<const IoHash&> auto MatchFunc) const { for (const IoHash& Candidate : Candidates) { @@ -36,7 +36,7 @@ public: } } - inline void FilterHashes(std::span<const IoHash> Candidates, Invocable<const IoHash&, bool> auto MatchFunc) const + inline void FilterHashes(eastl::span<const IoHash> Candidates, Invocable<const IoHash&, bool> auto MatchFunc) const { for (const IoHash& Candidate : Candidates) { diff --git a/src/zenstore/include/zenstore/scrubcontext.h b/src/zenstore/include/zenstore/scrubcontext.h index 2f28cfec7..73214e24c 100644 --- a/src/zenstore/include/zenstore/scrubcontext.h +++ b/src/zenstore/include/zenstore/scrubcontext.h @@ -22,7 +22,7 @@ public: std::chrono::steady_clock::time_point Deadline = std::chrono::steady_clock::time_point::max()); ~ScrubContext(); - void ReportBadCidChunks(std::span<IoHash> BadCasChunks); + void ReportBadCidChunks(eastl::span<IoHash> BadCasChunks); inline uint64_t ScrubTimestamp() const { return m_ScrubTime; } void ReportScrubbed(uint64_t ChunkCount, uint64_t ChunkBytes) { diff --git a/src/zenstore/include/zenstore/workspaces.h b/src/zenstore/include/zenstore/workspaces.h index f2eb119a9..c36429af8 100644 --- a/src/zenstore/include/zenstore/workspaces.h +++ b/src/zenstore/include/zenstore/workspaces.h @@ -71,10 +71,10 @@ public: ShareFile GetWorkspaceShareChunkInfo(const Oid& WorkspaceId, const Oid& ShareId, const Oid& ChunkId, WorkerThreadPool& WorkerPool); - eastl::vector<IoBuffer> GetWorkspaceShareChunks(const Oid& WorkspaceId, - const Oid& ShareId, - const std::span<const ChunkRequest> ChunkRequests, - WorkerThreadPool& WorkerPool); + eastl::vector<IoBuffer> GetWorkspaceShareChunks(const Oid& WorkspaceId, + const Oid& ShareId, + const eastl::span<const ChunkRequest> ChunkRequests, + WorkerThreadPool& WorkerPool); eastl::vector<Oid> GetWorkspaces() const; std::optional<WorkspaceConfiguration> GetWorkspaceConfiguration(const Oid& WorkspaceId) const; diff --git a/src/zenstore/scrubcontext.cpp b/src/zenstore/scrubcontext.cpp index fbcd7d33c..78b88673a 100644 --- a/src/zenstore/scrubcontext.cpp +++ b/src/zenstore/scrubcontext.cpp @@ -41,7 +41,7 @@ ScrubContext::IsBadCid(const IoHash& Cid) const } void -ScrubContext::ReportBadCidChunks(std::span<IoHash> BadCasChunks) +ScrubContext::ReportBadCidChunks(eastl::span<IoHash> BadCasChunks) { RwLock::ExclusiveLockScope _(m_Lock); m_BadCid.AddHashesToSet(BadCasChunks); diff --git a/src/zenstore/workspaces.cpp b/src/zenstore/workspaces.cpp index c33997d13..7e7ce5c38 100644 --- a/src/zenstore/workspaces.cpp +++ b/src/zenstore/workspaces.cpp @@ -27,7 +27,7 @@ namespace { static constexpr std::string_view WorkspacesConfigName("config.json"); static constexpr std::string_view WorkspaceConfigName("zenworkspaceconfig.json"); - std::string WorkspacesToJson(std::span<const Workspaces::WorkspaceConfiguration> Workspaces) + std::string WorkspacesToJson(eastl::span<const Workspaces::WorkspaceConfiguration> Workspaces) { using namespace std::literals; @@ -84,7 +84,7 @@ namespace { return {}; } - std::string WorkspaceSharesToJson(std::span<const Workspaces::WorkspaceShareConfiguration> WorkspaceShares) + std::string WorkspaceSharesToJson(eastl::span<const Workspaces::WorkspaceShareConfiguration> WorkspaceShares) { using namespace std::literals; @@ -569,10 +569,10 @@ Workspaces::GetWorkspaceShareChunkInfo(const Oid& WorkspaceId, const Oid& ShareI } eastl::vector<IoBuffer> -Workspaces::GetWorkspaceShareChunks(const Oid& WorkspaceId, - const Oid& ShareId, - const std::span<const ChunkRequest> ChunkRequests, - WorkerThreadPool& WorkerPool) +Workspaces::GetWorkspaceShareChunks(const Oid& WorkspaceId, + const Oid& ShareId, + const eastl::span<const ChunkRequest> ChunkRequests, + WorkerThreadPool& WorkerPool) { if (ChunkRequests.size() == 0) { |