]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:nil -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | ||
4 | #include "item_iterator_stage.h" | |
5 | ||
6 | #include "crimson/os/seastore/onode_manager/staged-fltree/node_extent_mutable.h" | |
7 | ||
8 | namespace crimson::os::seastore::onode { | |
9 | ||
10 | #define ITER_T item_iterator_t<NODE_TYPE> | |
11 | #define ITER_INST(NT) item_iterator_t<NT> | |
12 | ||
13 | template <node_type_t NODE_TYPE> | |
14 | template <KeyT KT> | |
15 | memory_range_t ITER_T::insert_prefix( | |
16 | NodeExtentMutable& mut, const ITER_T& iter, const full_key_t<KT>& key, | |
20effc67 TL |
17 | bool is_end, node_offset_t size, const char* p_left_bound) |
18 | { | |
f67539c2 TL |
19 | // 1. insert range |
20 | char* p_insert; | |
21 | if (is_end) { | |
22 | assert(!iter.has_next()); | |
23 | p_insert = const_cast<char*>(iter.p_start()); | |
24 | } else { | |
25 | p_insert = const_cast<char*>(iter.p_end()); | |
26 | } | |
27 | char* p_insert_front = p_insert - size; | |
28 | ||
29 | // 2. shift memory | |
30 | const char* p_shift_start = p_left_bound; | |
31 | const char* p_shift_end = p_insert; | |
32 | mut.shift_absolute(p_shift_start, | |
33 | p_shift_end - p_shift_start, | |
34 | -(int)size); | |
35 | ||
36 | // 3. append header | |
37 | p_insert -= sizeof(node_offset_t); | |
38 | node_offset_t back_offset = (p_insert - p_insert_front); | |
39 | mut.copy_in_absolute(p_insert, back_offset); | |
40 | ns_oid_view_t::append<KT>(mut, key, p_insert); | |
41 | ||
42 | return {p_insert_front, p_insert}; | |
43 | } | |
44 | #define IP_TEMPLATE(NT, KT) \ | |
45 | template memory_range_t ITER_INST(NT)::insert_prefix<KT>( \ | |
46 | NodeExtentMutable&, const ITER_INST(NT)&, const full_key_t<KT>&, \ | |
47 | bool, node_offset_t, const char*) | |
48 | IP_TEMPLATE(node_type_t::LEAF, KeyT::VIEW); | |
49 | IP_TEMPLATE(node_type_t::INTERNAL, KeyT::VIEW); | |
50 | IP_TEMPLATE(node_type_t::LEAF, KeyT::HOBJ); | |
51 | IP_TEMPLATE(node_type_t::INTERNAL, KeyT::HOBJ); | |
52 | ||
53 | template <node_type_t NODE_TYPE> | |
54 | void ITER_T::update_size( | |
20effc67 TL |
55 | NodeExtentMutable& mut, const ITER_T& iter, int change) |
56 | { | |
f67539c2 TL |
57 | node_offset_t offset = iter.get_back_offset(); |
58 | int new_size = change + offset; | |
20effc67 | 59 | assert(new_size > 0 && new_size < (int)mut.get_length()); |
f67539c2 TL |
60 | mut.copy_in_absolute( |
61 | (void*)iter.get_item_range().p_end, node_offset_t(new_size)); | |
62 | } | |
63 | ||
64 | template <node_type_t NODE_TYPE> | |
20effc67 TL |
65 | node_offset_t ITER_T::trim_until(NodeExtentMutable& mut, const ITER_T& iter) |
66 | { | |
f67539c2 TL |
67 | assert(iter.index() != 0); |
68 | size_t ret = iter.p_end() - iter.p_items_start; | |
20effc67 | 69 | assert(ret < mut.get_length()); |
f67539c2 TL |
70 | return ret; |
71 | } | |
72 | ||
73 | template <node_type_t NODE_TYPE> | |
74 | node_offset_t ITER_T::trim_at( | |
20effc67 TL |
75 | NodeExtentMutable& mut, const ITER_T& iter, node_offset_t trimmed) |
76 | { | |
f67539c2 | 77 | size_t trim_size = iter.p_start() - iter.p_items_start + trimmed; |
20effc67 | 78 | assert(trim_size < mut.get_length()); |
f67539c2 TL |
79 | assert(iter.get_back_offset() > trimmed); |
80 | node_offset_t new_offset = iter.get_back_offset() - trimmed; | |
81 | mut.copy_in_absolute((void*)iter.item_range.p_end, new_offset); | |
82 | return trim_size; | |
83 | } | |
84 | ||
20effc67 TL |
85 | template <node_type_t NODE_TYPE> |
86 | node_offset_t ITER_T::erase( | |
87 | NodeExtentMutable& mut, const ITER_T& iter, const char* p_left_bound) | |
88 | { | |
89 | node_offset_t erase_size = iter.p_end() - iter.p_start(); | |
90 | const char* p_shift_start = p_left_bound; | |
91 | assert(p_left_bound <= iter.p_start()); | |
92 | extent_len_t shift_len = iter.p_start() - p_left_bound; | |
93 | int shift_off = erase_size; | |
94 | mut.shift_absolute(p_shift_start, shift_len, shift_off); | |
95 | return erase_size; | |
96 | } | |
97 | ||
f67539c2 TL |
98 | #define ITER_TEMPLATE(NT) template class ITER_INST(NT) |
99 | ITER_TEMPLATE(node_type_t::LEAF); | |
100 | ITER_TEMPLATE(node_type_t::INTERNAL); | |
101 | ||
102 | #define APPEND_T ITER_T::Appender<KT> | |
103 | ||
104 | template <node_type_t NODE_TYPE> | |
105 | template <KeyT KT> | |
20effc67 TL |
106 | APPEND_T::Appender(NodeExtentMutable* p_mut, |
107 | const item_iterator_t& iter, | |
108 | bool open) : p_mut{p_mut} | |
109 | { | |
110 | assert(!iter.has_next()); | |
111 | if (open) { | |
112 | p_append = const_cast<char*>(iter.get_key().p_start()); | |
113 | p_offset_while_open = const_cast<char*>(iter.item_range.p_end); | |
114 | } else { | |
115 | // XXX: this doesn't need to advance the iter to last | |
116 | p_append = const_cast<char*>(iter.p_items_start); | |
117 | } | |
118 | } | |
119 | ||
120 | template <node_type_t NODE_TYPE> | |
121 | template <KeyT KT> | |
122 | bool APPEND_T::append(const ITER_T& src, index_t& items) | |
123 | { | |
f67539c2 TL |
124 | auto p_end = src.p_end(); |
125 | bool append_till_end = false; | |
126 | if (is_valid_index(items)) { | |
127 | for (auto i = 1u; i <= items; ++i) { | |
128 | if (!src.has_next()) { | |
129 | assert(i == items); | |
130 | append_till_end = true; | |
131 | break; | |
132 | } | |
133 | ++src; | |
134 | } | |
135 | } else { | |
136 | if (items == INDEX_END) { | |
137 | append_till_end = true; | |
138 | } else { | |
139 | assert(items == INDEX_LAST); | |
140 | } | |
141 | items = 0; | |
142 | while (src.has_next()) { | |
143 | ++src; | |
144 | ++items; | |
145 | } | |
146 | if (append_till_end) { | |
147 | ++items; | |
148 | } | |
149 | } | |
150 | ||
151 | const char* p_start; | |
152 | if (append_till_end) { | |
153 | p_start = src.p_start(); | |
154 | } else { | |
155 | p_start = src.p_end(); | |
156 | } | |
157 | assert(p_end >= p_start); | |
158 | size_t append_size = p_end - p_start; | |
159 | p_append -= append_size; | |
160 | p_mut->copy_in_absolute(p_append, p_start, append_size); | |
161 | return append_till_end; | |
162 | } | |
163 | ||
164 | template <node_type_t NODE_TYPE> | |
165 | template <KeyT KT> | |
166 | std::tuple<NodeExtentMutable*, char*> | |
20effc67 TL |
167 | APPEND_T::open_nxt(const key_get_type& partial_key) |
168 | { | |
f67539c2 TL |
169 | p_append -= sizeof(node_offset_t); |
170 | p_offset_while_open = p_append; | |
171 | ns_oid_view_t::append(*p_mut, partial_key, p_append); | |
172 | return {p_mut, p_append}; | |
173 | } | |
174 | ||
175 | template <node_type_t NODE_TYPE> | |
176 | template <KeyT KT> | |
177 | std::tuple<NodeExtentMutable*, char*> | |
20effc67 TL |
178 | APPEND_T::open_nxt(const full_key_t<KT>& key) |
179 | { | |
f67539c2 TL |
180 | p_append -= sizeof(node_offset_t); |
181 | p_offset_while_open = p_append; | |
182 | ns_oid_view_t::append<KT>(*p_mut, key, p_append); | |
183 | return {p_mut, p_append}; | |
184 | } | |
185 | ||
186 | template <node_type_t NODE_TYPE> | |
187 | template <KeyT KT> | |
20effc67 TL |
188 | void APPEND_T::wrap_nxt(char* _p_append) |
189 | { | |
f67539c2 TL |
190 | assert(_p_append < p_append); |
191 | p_mut->copy_in_absolute( | |
192 | p_offset_while_open, node_offset_t(p_offset_while_open - _p_append)); | |
193 | p_append = _p_append; | |
194 | } | |
195 | ||
196 | #define APPEND_TEMPLATE(NT, KT) template class ITER_INST(NT)::Appender<KT> | |
197 | APPEND_TEMPLATE(node_type_t::LEAF, KeyT::VIEW); | |
198 | APPEND_TEMPLATE(node_type_t::INTERNAL, KeyT::VIEW); | |
199 | APPEND_TEMPLATE(node_type_t::LEAF, KeyT::HOBJ); | |
200 | APPEND_TEMPLATE(node_type_t::INTERNAL, KeyT::HOBJ); | |
201 | ||
202 | } |