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
|
// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
#pragma once
#include "enumattribute.h"
#include <vespa/vespalib/util/rcuvector.h>
namespace search {
class ReaderBase;
/**
* Implementation of single value enum attribute that uses an underlying enum store
* to store unique values.
*
* B: EnumAttribute<BaseClass>
*/
class SingleValueEnumAttributeBase {
protected:
using AtomicEntryRef = vespalib::datastore::AtomicEntryRef;
using AtomicEntryRefVector = vespalib::RcuVectorBase<AtomicEntryRef>;
using DocId = AttributeVector::DocId;
using EntryRef = vespalib::datastore::EntryRef;
using EnumHandle = AttributeVector::EnumHandle;
using EnumIndex = IEnumStore::Index;
using EnumIndexRemapper = IEnumStore::EnumIndexRemapper;
using GenerationHolder = vespalib::GenerationHolder;
using EnumRefs = attribute::IAttributeVector::EnumRefs;
protected:
EntryRef acquire_enum_entry_ref(DocId docId) const noexcept { return _enumIndices.acquire_elem_ref(docId).load_acquire(); }
EnumHandle getE(DocId doc) const noexcept { return acquire_enum_entry_ref(doc).ref(); }
EnumRefs make_read_view(size_t read_size) const noexcept { return _enumIndices.make_read_view(read_size); }
SingleValueEnumAttributeBase(const attribute::Config & c, GenerationHolder &genHolder, const vespalib::alloc::Alloc& initial_alloc);
~SingleValueEnumAttributeBase();
AttributeVector::DocId addDoc(bool & incGeneration);
AtomicEntryRefVector _enumIndices;
void remap_enum_store_refs(const EnumIndexRemapper& remapper, AttributeVector& v);
};
template <typename B>
class SingleValueEnumAttribute : public B, public SingleValueEnumAttributeBase {
protected:
using Change = typename B::Change;
using ChangeVector = typename B::ChangeVector;
using DocId = typename B::DocId;
using EnumStore = typename B::EnumStore;
using EnumStoreBatchUpdater = typename EnumStore::BatchUpdater;
using LoadedVector = typename B::LoadedVector;
using ValueModifier = typename B::ValueModifier;
using WeightedEnum = typename B::WeightedEnum;
using generation_t = typename B::generation_t;
using B::getGenerationHolder;
private:
void considerUpdateAttributeChange(const Change & c, EnumStoreBatchUpdater & inserter);
void applyUpdateValueChange(const Change& c, EnumStoreBatchUpdater& updater);
EnumRefs make_enum_read_view() const noexcept override {
return make_read_view(this->getCommittedDocIdLimit());
}
protected:
// from EnumAttribute
void considerAttributeChange(const Change & c, EnumStoreBatchUpdater & inserter) override;
// implemented by single value numeric enum attribute.
virtual void considerUpdateAttributeChange(DocId, const Change&) { }
virtual void considerArithmeticAttributeChange(const Change & c, EnumStoreBatchUpdater & inserter) { (void) c; (void) inserter; }
virtual void applyValueChanges(EnumStoreBatchUpdater& updater) ;
virtual void applyArithmeticValueChange(const Change& c, EnumStoreBatchUpdater& updater) {
(void) c; (void) updater;
}
void updateEnumRefCounts(DocId doc, EnumIndex newIdx, EnumIndex oldIdx, EnumStoreBatchUpdater& updater);
virtual void freezeEnumDictionary() {
this->getEnumStore().freeze_dictionary();
}
virtual void mergeMemoryStats(vespalib::MemoryUsage & total) { (void) total; }
void fillValues(LoadedVector & loaded) override;
void load_enumerated_data(ReaderBase& attrReader,
enumstore::EnumeratedPostingsLoader& loader, size_t num_values) override;
void load_enumerated_data(ReaderBase& attrReader,
enumstore::EnumeratedLoader& loader) override;
/**
* Called when a new document has been added.
*
* Can be overridden by subclasses that need to resize structures
* as a result of this.
*
* Should return true if underlying structures were resized.
**/
bool onAddDoc(DocId doc) override;
public:
SingleValueEnumAttribute(const vespalib::string & baseFileName, const AttributeVector::Config & cfg);
~SingleValueEnumAttribute();
bool addDoc(DocId & doc) override;
uint32_t getValueCount(DocId doc) const override;
void onCommit() override;
void onUpdateStat() override;
void reclaim_memory(generation_t oldest_used_gen) override;
void before_inc_generation(generation_t current_gen) override;
EnumHandle getEnum(DocId doc) const override {
return getE(doc);
}
uint32_t get(DocId doc, EnumHandle * e, uint32_t sz) const override {
if (sz > 0) {
e[0] = getE(doc);
}
return 1;
}
uint32_t get(DocId doc, WeightedEnum * e, uint32_t sz) const override {
if (sz > 0) {
e[0] = WeightedEnum(getE(doc), 1);
}
return 1;
}
void clearDocs(DocId lidLow, DocId lidLimit, bool in_shrink_lid_space) override;
void onShrinkLidSpace() override;
std::unique_ptr<AttributeSaver> onInitSave(vespalib::stringref fileName) override;
void onAddDocs(DocId lidLimit) override;
};
} // namespace search
|
