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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#pragma once
#include "attribute_collection_spec.h"
#include "i_attribute_factory.h"
#include "i_attribute_manager.h"
#include "i_attribute_initializer_registry.h"
#include <set>
#include <vespa/searchlib/common/tunefileinfo.h>
#include <vespa/vespalib/stllike/hash_map.h>
#include <vespa/searchcore/proton/common/hw_info.h>
namespace search::attribute { class Interlock; }
namespace search::common { class FileHeaderContext; }
namespace searchcorespi { class IFlushTarget; }
namespace vespalib { class ThreadExecutor; }
namespace proton {
class AttributeDiskLayout;
class FlushableAttribute;
class ShrinkLidSpaceFlushTarget;
/**
* Specialized attribute manager for proton.
*/
class AttributeManager : public proton::IAttributeManager
{
private:
using AttributeReadGuard = search::attribute::AttributeReadGuard;
using AttributeVectorSP = std::shared_ptr<search::AttributeVector>;
using Config = search::attribute::Config;
using FlushableAttributeSP = std::shared_ptr<FlushableAttribute>;
using IFlushTargetSP = std::shared_ptr<searchcorespi::IFlushTarget>;
using SerialNum = search::SerialNum;
using ShrinkerSP = std::shared_ptr<ShrinkLidSpaceFlushTarget>;
using Spec = AttributeCollectionSpec;
class AttributeWrap
{
private:
AttributeVectorSP _attr;
bool _isExtra;
AttributeWrap(AttributeVectorSP a, bool isExtra_);
public:
AttributeWrap();
AttributeWrap(const AttributeWrap &) = default;
AttributeWrap & operator=(const AttributeWrap &) = delete;
AttributeWrap(AttributeWrap &&) noexcept = default;
AttributeWrap & operator=(AttributeWrap &&) noexcept = default;
~AttributeWrap();
static AttributeWrap extraAttribute(AttributeVectorSP a);
static AttributeWrap normalAttribute(AttributeVectorSP a);
bool isExtra() const { return _isExtra; }
const AttributeVectorSP & getAttribute() const { return _attr; }
};
class FlushableWrap
{
FlushableAttributeSP _flusher;
ShrinkerSP _shrinker;
public:
FlushableWrap();
FlushableWrap(FlushableAttributeSP flusher, ShrinkerSP shrinker);
~FlushableWrap();
const FlushableAttributeSP &getFlusher() const { return _flusher; }
const ShrinkerSP &getShrinker() const { return _shrinker; }
};
using AttributeMap = vespalib::hash_map<vespalib::string, AttributeWrap>;
using FlushableMap = vespalib::hash_map<vespalib::string, FlushableWrap>;
AttributeMap _attributes;
FlushableMap _flushables;
std::vector<search::AttributeVector *> _writableAttributes;
std::shared_ptr<AttributeDiskLayout> _diskLayout;
vespalib::string _documentSubDbName;
const search::TuneFileAttributes _tuneFileAttributes;
const search::common::FileHeaderContext &_fileHeaderContext;
IAttributeFactory::SP _factory;
std::shared_ptr<search::attribute::Interlock> _interlock;
vespalib::ISequencedTaskExecutor &_attributeFieldWriter;
vespalib::Executor& _shared_executor;
HwInfo _hwInfo;
std::unique_ptr<ImportedAttributesRepo> _importedAttributes;
AttributeVectorSP internalAddAttribute(AttributeSpec && spec, uint64_t serialNum, const IAttributeFactory &factory);
void addAttribute(AttributeWrap attribute, const ShrinkerSP &shrinker);
AttributeVectorSP findAttribute(const vespalib::string &name) const;
const FlushableWrap *findFlushable(const vespalib::string &name) const;
Spec::AttributeList transferExistingAttributes(const AttributeManager &currMgr, Spec::AttributeList && newAttributes);
void addNewAttributes(const Spec &newSpec, Spec::AttributeList && toBeAdded, IAttributeInitializerRegistry &initializerRegistry);
void transferExtraAttributes(const AttributeManager &currMgr);
public:
using SP = std::shared_ptr<AttributeManager>;
AttributeManager(const vespalib::string &baseDir,
const vespalib::string &documentSubDbName,
const search::TuneFileAttributes &tuneFileAttributes,
const search::common::FileHeaderContext & fileHeaderContext,
std::shared_ptr<search::attribute::Interlock> interlock,
vespalib::ISequencedTaskExecutor &attributeFieldWriter,
vespalib::Executor& shared_executor,
const HwInfo &hwInfo);
AttributeManager(const vespalib::string &baseDir,
const vespalib::string &documentSubDbName,
const search::TuneFileAttributes &tuneFileAttributes,
const search::common::FileHeaderContext & fileHeaderContext,
std::shared_ptr<search::attribute::Interlock> interlock,
vespalib::ISequencedTaskExecutor &attributeFieldWriter,
vespalib::Executor& shared_executor,
IAttributeFactory::SP factory,
const HwInfo &hwInfo);
AttributeManager(const AttributeManager &currMgr, Spec && newSpec,
IAttributeInitializerRegistry &initializerRegistry);
~AttributeManager() override;
AttributeVectorSP addAttribute(AttributeSpec && spec, uint64_t serialNum);
void addInitializedAttributes(const std::vector<AttributeInitializerResult> &attributes, std::optional<uint32_t> docid_limit, std::optional<SerialNum> serial_num);
void addExtraAttribute(const AttributeVectorSP &attribute);
void flushAll(SerialNum currentSerial);
FlushableAttributeSP getFlushable(const vespalib::string &name);
ShrinkerSP getShrinker(const vespalib::string &name);
size_t getNumDocs() const;
static void padAttribute(search::AttributeVector &v, uint32_t docIdLimit);
// Implements search::IAttributeManager
search::AttributeGuard::UP getAttribute(const vespalib::string &name) const override;
std::unique_ptr<AttributeReadGuard> getAttributeReadGuard(const string &name, bool stableEnumGuard) const override;
/**
* Fills all regular registered attributes (not extra attributes)
* into the given list.
*/
void getAttributeList(std::vector<search::AttributeGuard> &list) const override;
search::attribute::IAttributeContext::UP createContext() const override;
// Implements proton::IAttributeManager
std::unique_ptr<AttributeManagerReconfig> prepare_create(Spec && spec) const override;
proton::IAttributeManager::SP create(Spec && spec) const override;
std::vector<IFlushTargetSP> getFlushTargets() const override;
search::SerialNum getFlushedSerialNum(const vespalib::string &name) const override;
SerialNum getOldestFlushedSerialNumber() const override;
search::SerialNum getNewestFlushedSerialNumber() const override;
void getAttributeListAll(std::vector<search::AttributeGuard> &list) const override;
void pruneRemovedFields(search::SerialNum serialNum) override;
const IAttributeFactory::SP &getFactory() const override { return _factory; }
vespalib::ISequencedTaskExecutor &getAttributeFieldWriter() const override;
vespalib::Executor& get_shared_executor() const override { return _shared_executor; }
search::AttributeVector *getWritableAttribute(const vespalib::string &name) const override;
const std::vector<search::AttributeVector *> &getWritableAttributes() const override;
void asyncForEachAttribute(std::shared_ptr<IConstAttributeFunctor> func) const override;
void asyncForEachAttribute(std::shared_ptr<IAttributeFunctor> func, OnDone onDone) const override;
void asyncForAttribute(const vespalib::string &name, std::unique_ptr<IAttributeFunctor> func) const override;
ExclusiveAttributeReadAccessor::UP getExclusiveReadAccessor(const vespalib::string &name) const override;
void setImportedAttributes(std::unique_ptr<ImportedAttributesRepo> attributes) override;
const ImportedAttributesRepo *getImportedAttributes() const override { return _importedAttributes.get(); }
std::shared_ptr<search::attribute::ReadableAttributeVector> readable_attribute_vector(const string& name) const override;
TransientResourceUsage get_transient_resource_usage() const override;
};
} // namespace proton
|
