blob: de79b8b81901a6926dbe1d8fdc0e3572146d4606 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include <zencore/zencore.h>
#include <zencore/filesystem.h>
#include <zencore/iobuffer.h>
#include <zencore/iohash.h>
#include <zencore/thread.h>
#include <zenstore/caslog.h>
#include <zenstore/gc.h>
#include "cas.h"
#include <atomic>
#include <functional>
namespace spdlog {
class logger;
}
namespace zen {
class BasicFile;
/** CAS storage strategy using a file-per-chunk storage strategy
*/
struct FileCasStrategy final : public GcStorage
{
FileCasStrategy(GcManager& Gc);
~FileCasStrategy();
void Initialize(const std::filesystem::path& RootDirectory, bool IsNewStore);
CasStore::InsertResult InsertChunk(const void* ChunkData, size_t ChunkSize, const IoHash& ChunkHash);
CasStore::InsertResult InsertChunk(IoBuffer Chunk,
const IoHash& ChunkHash,
CasStore::InsertMode Mode = CasStore::InsertMode::kMayBeMovedInPlace);
IoBuffer FindChunk(const IoHash& ChunkHash);
bool HaveChunk(const IoHash& ChunkHash);
void FilterChunks(HashKeySet& InOutChunks);
void Flush();
void Scrub(ScrubContext& Ctx);
virtual void CollectGarbage(GcContext& GcCtx) override;
virtual GcStorageSize StorageSize() const override { return {.DiskSize = m_TotalSize.load(std::memory_order::relaxed)}; }
private:
std::filesystem::path m_RootDirectory;
RwLock m_Lock;
RwLock m_ShardLocks[256]; // TODO: these should be spaced out so they don't share cache lines
spdlog::logger& m_Log;
spdlog::logger& Log() { return m_Log; }
std::atomic_uint64_t m_TotalSize{};
bool m_IsInitialized = false;
struct FileCasIndexEntry
{
static const uint32_t kTombStone = 0x0000'0001;
bool IsFlagSet(const uint32_t Flag) const { return (Flags & kTombStone) == Flag; }
IoHash Key;
uint32_t Flags = 0;
uint64_t Size = 0;
};
static_assert(sizeof(FileCasIndexEntry) == 32);
TCasLogFile<FileCasIndexEntry> m_CasLog;
inline RwLock& LockForHash(const IoHash& Hash) { return m_ShardLocks[Hash.Hash[19]]; }
void IterateChunks(std::function<void(const IoHash& Hash, BasicFile& PayloadFile)>&& Callback);
void DeleteChunk(const IoHash& ChunkHash, std::error_code& Ec);
struct ShardingHelper
{
ShardingHelper(const std::filesystem::path& RootPath, const IoHash& ChunkHash);
size_t Shard2len = 0;
ExtendablePathBuilder<128> ShardedPath;
};
};
void filecas_forcelink();
} // namespace zen
|