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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
//===- OnDiskKeyValueDB.cpp -------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
/// \file
/// This file implements OnDiskKeyValueDB, an ondisk key value database.
///
/// The KeyValue database file is named `actions.<version>` inside the CAS
/// directory. The database stores a mapping between a fixed-sized key and a
/// fixed-sized value, where the size of key and value can be configured when
/// opening the database.
///
//
//===----------------------------------------------------------------------===//
#include "llvm/CAS/OnDiskKeyValueDB.h"
#include "OnDiskCommon.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Alignment.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/Path.h"
using namespace llvm;
using namespace llvm::cas;
using namespace llvm::cas::ondisk;
static constexpr StringLiteral ActionCacheFile = "actions.";
Expected<ArrayRef<char>> OnDiskKeyValueDB::put(ArrayRef<uint8_t> Key,
ArrayRef<char> Value) {
if (LLVM_UNLIKELY(Value.size() != ValueSize))
return createStringError(errc::invalid_argument,
"expected value size of " + itostr(ValueSize) +
", got: " + itostr(Value.size()));
assert(Value.size() == ValueSize);
auto ActionP = Cache.insertLazy(
Key, [&](FileOffset TentativeOffset,
OnDiskTrieRawHashMap::ValueProxy TentativeValue) {
assert(TentativeValue.Data.size() == ValueSize);
llvm::copy(Value, TentativeValue.Data.data());
});
if (LLVM_UNLIKELY(!ActionP))
return ActionP.takeError();
return (*ActionP)->Data;
}
Expected<std::optional<ArrayRef<char>>>
OnDiskKeyValueDB::get(ArrayRef<uint8_t> Key) {
// Check the result cache.
OnDiskTrieRawHashMap::ConstOnDiskPtr ActionP = Cache.find(Key);
if (!ActionP)
return std::nullopt;
assert(isAddrAligned(Align(8), ActionP->Data.data()));
return ActionP->Data;
}
Expected<std::unique_ptr<OnDiskKeyValueDB>>
OnDiskKeyValueDB::open(StringRef Path, StringRef HashName, unsigned KeySize,
StringRef ValueName, size_t ValueSize) {
if (std::error_code EC = sys::fs::create_directories(Path))
return createFileError(Path, EC);
SmallString<256> CachePath(Path);
sys::path::append(CachePath, ActionCacheFile + CASFormatVersion);
constexpr uint64_t MB = 1024ull * 1024ull;
constexpr uint64_t GB = 1024ull * 1024ull * 1024ull;
uint64_t MaxFileSize = GB;
auto CustomSize = getOverriddenMaxMappingSize();
if (!CustomSize)
return CustomSize.takeError();
if (*CustomSize)
MaxFileSize = **CustomSize;
std::optional<OnDiskTrieRawHashMap> ActionCache;
if (Error E = OnDiskTrieRawHashMap::create(
CachePath,
"llvm.actioncache[" + HashName + "->" + ValueName + "]",
KeySize * 8,
/*DataSize=*/ValueSize, MaxFileSize, /*MinFileSize=*/MB)
.moveInto(ActionCache))
return std::move(E);
return std::unique_ptr<OnDiskKeyValueDB>(
new OnDiskKeyValueDB(ValueSize, std::move(*ActionCache)));
}
Error OnDiskKeyValueDB::validate(CheckValueT CheckValue) const {
return Cache.validate(
[&](FileOffset Offset,
OnDiskTrieRawHashMap::ConstValueProxy Record) -> Error {
auto formatError = [&](Twine Msg) {
return createStringError(
llvm::errc::illegal_byte_sequence,
"bad cache value at 0x" +
utohexstr((unsigned)Offset.get(), /*LowerCase=*/true) + ": " +
Msg.str());
};
if (Record.Data.size() != ValueSize)
return formatError("wrong cache value size");
if (!isAddrAligned(Align(8), Record.Data.data()))
return formatError("wrong cache value alignment");
if (CheckValue)
return CheckValue(Offset, Record.Data);
return Error::success();
});
}
|
