OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <storage/browser/blob/blob_async_transport_strategy.h> | |
kinuko
2015/11/17 14:51:42
nit: use "" instead of <> and have empty line per
dmurph
2015/11/17 20:40:19
Done. Eclipse artifact.
| |
6 #include <algorithm> | |
7 | |
8 #include "storage/common/blob_storage/blob_storage_constants.h" | |
9 | |
10 namespace storage { | |
11 | |
12 namespace { | |
13 | |
14 const char* kTemporaryFileName = "TODO(dmurph) Replace with real filename"; | |
michaeln
2015/11/17 21:55:28
what about this? make the TODO a comment and the f
dmurph
2015/11/19 02:06:18
That only adds an extra line of code. This is del
| |
15 | |
16 bool IsBytes(DataElement::Type type) { | |
17 return type == DataElement::TYPE_BYTES || | |
18 type == DataElement::TYPE_BYTES_DESCRIPTION; | |
19 } | |
20 | |
21 // This class handles the logic of how transported memory is going to be | |
22 // represented as storage in the browser. The main idea is that all the memory | |
23 // is now packed into file chunks, and the browser items will just reference | |
24 // the file with offsets and sizes. | |
25 class FileStorageStrategy | |
26 : public BlobAsyncTransportStrategy::BlobSegmentVisitor<uint64_t> { | |
27 public: | |
28 typedef uint64_t SizeType; | |
29 | |
30 FileStorageStrategy( | |
31 std::vector<BlobAsyncTransportStrategy::MemoryItemRequest>* requests, | |
32 BlobDataBuilder* builder) | |
33 : requests(requests), builder(builder), current_storage_item(0) {} | |
34 | |
35 ~FileStorageStrategy() override {} | |
36 | |
37 void VisitSegment(const DataElement& element, | |
38 size_t element_index, | |
39 SizeType element_offset, | |
40 size_t segment_index, | |
41 SizeType segment_offset, | |
42 SizeType size) override { | |
43 if (!IsBytes(element.type())) { | |
44 builder->AppendDataElement(element); | |
45 current_storage_item++; | |
46 return; | |
47 } | |
48 BlobAsyncTransportStrategy::MemoryItemRequest request; | |
49 request.browser_item_index = current_storage_item; | |
50 request.browser_item_offset = 0; | |
51 request.message.request_number = requests->size(); | |
52 request.message.transport_strategy = IPCBlobItemRequestStrategy::FILE; | |
53 request.message.renderer_item_index = element_index; | |
54 request.message.renderer_item_offset = element_offset; | |
55 request.message.size = size; | |
56 request.message.handle_index = segment_index; | |
57 request.message.handle_offset = segment_offset; | |
58 | |
59 requests->push_back(request); | |
60 builder->AppendFile( | |
61 base::FilePath::FromUTF8Unsafe(std::string(kTemporaryFileName)), | |
62 segment_offset, size, base::Time::FromDoubleT(0)); | |
63 current_storage_item++; | |
64 }; | |
65 | |
66 void Done() override {} | |
67 | |
68 std::vector<BlobAsyncTransportStrategy::MemoryItemRequest>* requests; | |
69 BlobDataBuilder* builder; | |
70 | |
71 size_t current_storage_item; | |
72 }; | |
73 | |
74 // This class handles the logic of storing memory that is transported as | |
75 // consolidated shared memory. The main hurdle is to re-separate memory blocks | |
76 // that cross file or blob boundaries. | |
77 class SharedMemoryStorageStrategy | |
78 : public BlobAsyncTransportStrategy::BlobSegmentVisitor<size_t> { | |
79 public: | |
80 typedef size_t SizeType; | |
81 | |
82 SharedMemoryStorageStrategy( | |
83 SizeType max_segment_size, | |
84 std::vector<BlobAsyncTransportStrategy::MemoryItemRequest>* requests, | |
85 BlobDataBuilder* builder) | |
86 : requests(requests), | |
87 max_segment_size(max_segment_size), | |
88 storage_element_offset(0), | |
89 builder(builder), | |
90 current_item_size(0), | |
91 current_storage_item(0) {} | |
92 ~SharedMemoryStorageStrategy() override {} | |
93 | |
94 void VisitSegment(const DataElement& element, | |
95 size_t element_index, | |
96 SizeType element_offset, | |
97 size_t segment_index, | |
98 SizeType segment_offset, | |
99 SizeType size) override { | |
100 if (!IsBytes(element.type())) { | |
101 builder->AppendFutureData(current_item_size); | |
102 current_storage_item++; | |
103 builder->AppendDataElement(element); | |
104 current_storage_item++; | |
105 storage_element_offset = 0; | |
106 current_item_size = 0; | |
107 return; | |
108 } | |
109 if (storage_element_offset + size > max_segment_size) { | |
110 builder->AppendFutureData(current_item_size); | |
111 current_storage_item++; | |
112 current_item_size = 0; | |
113 storage_element_offset = 0; | |
114 } | |
115 BlobAsyncTransportStrategy::MemoryItemRequest request; | |
116 request.browser_item_index = current_storage_item; | |
117 request.browser_item_offset = storage_element_offset; | |
118 request.message.request_number = requests->size(); | |
119 request.message.transport_strategy = | |
120 IPCBlobItemRequestStrategy::SHARED_MEMORY; | |
121 request.message.renderer_item_index = element_index; | |
122 request.message.renderer_item_offset = element_offset; | |
123 request.message.size = size; | |
124 request.message.handle_index = segment_index; | |
125 request.message.handle_offset = segment_offset; | |
126 | |
127 requests->push_back(request); | |
128 storage_element_offset += size; | |
129 current_item_size += size; | |
130 }; | |
131 | |
132 void Done() override { | |
133 if (current_item_size != 0) { | |
134 builder->AppendFutureData(current_item_size); | |
135 } | |
136 } | |
137 | |
138 std::vector<BlobAsyncTransportStrategy::MemoryItemRequest>* requests; | |
139 | |
140 SizeType max_segment_size; | |
141 SizeType storage_element_offset; | |
142 BlobDataBuilder* builder; | |
143 SizeType current_item_size; | |
144 size_t current_storage_item; | |
145 }; | |
146 } // namespace | |
147 | |
148 BlobAsyncTransportStrategy::MemoryItemRequest::MemoryItemRequest() | |
149 : browser_item_index(0), browser_item_offset(0), received(false) {} | |
150 | |
151 BlobAsyncTransportStrategy::BlobAsyncTransportStrategy() | |
152 : error_(BlobAsyncTransportStrategy::ERROR_NONE), total_bytes_size_(0) {} | |
153 | |
154 BlobAsyncTransportStrategy::~BlobAsyncTransportStrategy() {} | |
155 | |
michaeln
2015/11/17 21:55:28
A comment like the one you made in the review log
dmurph
2015/11/19 02:06:18
Done.
| |
156 void BlobAsyncTransportStrategy::Initialize( | |
157 BlobAsyncTransportStrategy::Mode mode, | |
michaeln
2015/11/17 21:55:28
Is MODE_NO_DISK functionally equivalent to MODE_DI
dmurph
2015/11/19 02:06:17
Not quite, but I changed it so it is.
After doing
| |
158 size_t max_ipc_memory_size, | |
159 size_t max_shared_memory_size, | |
160 uint64_t max_file_size, | |
161 size_t max_blob_in_memory_size, | |
162 uint64_t disk_space_left, | |
163 size_t memory_left, | |
164 const std::string& uuid, | |
165 const std::vector<DataElement>& blob_item_infos) { | |
166 file_handles_.clear(); | |
167 shared_memory_handles_.clear(); | |
168 requests_.clear(); | |
169 builder_.reset(new BlobDataBuilder(uuid)); | |
170 error_ = BlobAsyncTransportStrategy::ERROR_NONE; | |
171 | |
172 size_t memory_items = 0; | |
173 total_bytes_size_ = 0; | |
174 for (const auto& info : blob_item_infos) { | |
175 if (!IsBytes(info.type())) { | |
176 continue; | |
177 } | |
178 total_bytes_size_ += info.length(); | |
179 ++memory_items; | |
180 } | |
181 | |
182 switch (mode) { | |
183 case BlobAsyncTransportStrategy::MODE_DISK: | |
184 if (total_bytes_size_ > | |
185 disk_space_left + static_cast<uint64_t>(memory_left)) { | |
186 error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE; | |
187 return; | |
188 } | |
189 if (total_bytes_size_ > max_blob_in_memory_size) { | |
190 if (total_bytes_size_ > disk_space_left) { | |
191 error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE; | |
192 return; | |
193 } | |
194 CreateHandleSizes(total_bytes_size_, max_file_size, &file_handles_); | |
195 FileStorageStrategy strategy(&requests_, builder_.get()); | |
196 ForEachWithSegment(blob_item_infos, max_file_size, &strategy); | |
197 return; | |
198 } | |
199 break; | |
200 case BlobAsyncTransportStrategy::MODE_NO_DISK: | |
201 if (total_bytes_size_ > memory_left) { | |
michaeln
2015/11/17 21:55:28
It looks like it is provided |memory_left| is less
dmurph
2015/11/19 02:06:17
Done.
| |
202 error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE; | |
203 return; | |
204 } | |
205 break; | |
206 default: | |
207 NOTREACHED() << "Invalid mode " << mode; | |
208 error_ = BlobAsyncTransportStrategy::ERROR_INVALID_PARAMS; | |
209 return; | |
210 } | |
211 | |
212 if (total_bytes_size_ > max_ipc_memory_size) { | |
213 CHECK_LE(total_bytes_size_, std::numeric_limits<size_t>::max()); | |
214 CreateHandleSizes(static_cast<size_t>(total_bytes_size_), | |
215 max_shared_memory_size, &shared_memory_handles_); | |
216 SharedMemoryStorageStrategy strategy(max_shared_memory_size, &requests_, | |
217 builder_.get()); | |
218 ForEachWithSegment(blob_item_infos, max_shared_memory_size, &strategy); | |
219 return; | |
220 } | |
221 // Since they can all fit in IPC memory, we don't need to segment anything, | |
222 // and just request them straight in IPC. | |
223 size_t items_length = blob_item_infos.size(); | |
224 for (size_t i = 0; i < items_length; i++) { | |
225 const auto& info = blob_item_infos.at(i); | |
226 if (!IsBytes(info.type())) { | |
227 builder_->AppendDataElement(info); | |
228 continue; | |
229 } | |
230 BlobAsyncTransportStrategy::MemoryItemRequest request; | |
231 request.browser_item_index = i; | |
232 request.browser_item_offset = 0; | |
233 request.message.request_number = requests_.size(); | |
234 request.message.transport_strategy = IPCBlobItemRequestStrategy::IPC; | |
235 request.message.renderer_item_index = i; | |
236 request.message.renderer_item_offset = 0; | |
237 request.message.size = info.length(); | |
238 requests_.push_back(request); | |
239 builder_->AppendFutureData(info.length()); | |
240 } | |
241 } | |
242 | |
michaeln
2015/11/17 21:55:28
This was the note i made at some point to help me
dmurph
2015/11/19 02:06:17
Done, also added a bit to clarify that a segment c
| |
243 template <typename SizeType> | |
244 /* static */ void BlobAsyncTransportStrategy::ForEachWithSegment( | |
245 const std::vector<DataElement>& items, | |
michaeln
2015/11/17 21:55:28
it'd be good to use consistent local names for the
dmurph
2015/11/19 02:06:18
Done.
| |
246 SizeType max_segment_size, | |
247 BlobSegmentVisitor<SizeType>* visitor) { | |
248 DCHECK_GT(max_segment_size, 0ull); | |
249 size_t segment_index = 0; | |
250 SizeType segment_offset = 0; | |
251 size_t items_length = items.size(); | |
252 for (size_t element_index = 0; element_index < items_length; | |
253 ++element_index) { | |
254 const auto& element = items.at(element_index); | |
255 DataElement::Type type = element.type(); | |
256 if (!IsBytes(type)) { | |
257 visitor->VisitSegment(element, element_index, 0, 0, 0, 0); | |
michaeln
2015/11/17 21:55:28
The caller and the callee both have special cases
dmurph
2015/11/19 02:06:17
Done.
| |
258 continue; | |
259 } | |
260 SizeType element_memory_left = element.length(); | |
261 SizeType element_offset = 0; | |
262 while (element_memory_left > 0) { | |
263 if (segment_offset == max_segment_size) { | |
264 ++segment_index; | |
265 segment_offset = 0; | |
266 } | |
267 SizeType memory_writing = | |
268 std::min(max_segment_size - segment_offset, element_memory_left); | |
269 visitor->VisitSegment(element, element_index, element_offset, | |
270 segment_index, segment_offset, memory_writing); | |
271 element_memory_left -= memory_writing; | |
272 segment_offset += memory_writing; | |
273 element_offset += memory_writing; | |
274 } | |
275 } | |
276 visitor->Done(); | |
277 } | |
278 | |
279 /* static */ bool BlobAsyncTransportStrategy::ShouldBeShortcut( | |
michaeln
2015/11/17 21:55:28
style nit: this kind of comment in front of the re
dmurph
2015/11/19 02:06:17
ok.
| |
280 const std::vector<DataElement>& items, | |
281 size_t memory_available) { | |
282 size_t items_length = items.size(); | |
283 size_t shortcut_bytes = 0; | |
284 for (size_t element_index = 0; element_index < items_length; | |
michaeln
2015/11/17 21:55:28
would a simpler loop construct work here and also
dmurph
2015/11/19 02:06:17
Yes in this one, but in the ForEach I need the ind
| |
285 ++element_index) { | |
286 const auto& element = items.at(element_index); | |
287 DataElement::Type type = element.type(); | |
288 if (type == DataElement::TYPE_BYTES_DESCRIPTION) { | |
289 return false; | |
290 } | |
291 if (type == DataElement::TYPE_BYTES) { | |
292 shortcut_bytes += element.length(); | |
293 } | |
294 } | |
295 return shortcut_bytes <= memory_available; | |
296 } | |
297 | |
298 template <typename SizeType> | |
299 /* static */ void BlobAsyncTransportStrategy::CreateHandleSizes( | |
300 SizeType total_memory_size, | |
301 SizeType max_segment_size, | |
302 std::vector<SizeType>* segment_sizes) { | |
303 SizeType memory_left = total_memory_size; | |
304 SizeType segment_size; | |
305 for (; memory_left > 0; memory_left -= segment_size) { | |
michaeln
2015/11/17 21:55:28
can this be done with modulo math w/o looping?
v
dmurph
2015/11/19 02:06:17
Sure.
| |
306 segment_size = std::min(max_segment_size, memory_left); | |
307 segment_sizes->push_back(segment_size); | |
308 } | |
309 } | |
310 | |
311 } // namespace storage | |
OLD | NEW |