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 <algorithm> | |
6 | |
7 #include "storage/browser/blob/blob_async_transport_strategy.h" | |
8 #include "storage/common/blob_storage/blob_storage_constants.h" | |
9 | |
10 namespace storage { | |
11 namespace { | |
12 bool IsBytes(DataElement::Type type) { | |
13 return type == DataElement::TYPE_BYTES || | |
14 type == DataElement::TYPE_BYTES_DESCRIPTION; | |
15 } | |
16 } // namespace | |
17 | |
18 // This class handles the logic of how transported memory is going to be | |
19 // represented as storage in the browser. The main idea is that all the memory | |
20 // is now packed into file chunks, and the browser items will just reference | |
21 // the file with offsets and sizes. | |
22 class FileStorageStrategy | |
23 : public BlobAsyncTransportStrategy::BlobSegmentVisitor<uint64_t> { | |
24 public: | |
25 typedef uint64_t SizeType; | |
26 | |
27 FileStorageStrategy( | |
28 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* | |
29 requests, | |
30 BlobDataBuilder* builder) | |
31 : requests(requests), builder(builder), current_storage_item(0) {} | |
32 | |
33 ~FileStorageStrategy() override {} | |
34 | |
35 void VisitBytesSegment(size_t element_index, | |
36 SizeType element_offset, | |
37 size_t segment_index, | |
38 SizeType segment_offset, | |
39 SizeType size) override { | |
40 BlobAsyncTransportStrategy::RendererMemoryItemRequest request; | |
41 request.browser_item_index = current_storage_item; | |
42 request.browser_item_offset = 0; | |
43 request.message.request_number = requests->size(); | |
44 request.message.transport_strategy = IPCBlobItemRequestStrategy::FILE; | |
45 request.message.renderer_item_index = element_index; | |
46 request.message.renderer_item_offset = element_offset; | |
47 request.message.size = size; | |
48 request.message.handle_index = segment_index; | |
49 request.message.handle_offset = segment_offset; | |
50 | |
51 requests->push_back(request); | |
52 builder->AppendFutureFile(segment_offset, size); | |
michaeln
2015/11/21 00:59:45
AppendFuture and PopulateFuture, nice choice for n
| |
53 current_storage_item++; | |
54 } | |
55 | |
56 void VisitNonBytesSegment(const DataElement& element, | |
57 size_t element_index) override { | |
58 builder->AppendIPCDataElement(element); | |
59 current_storage_item++; | |
60 } | |
61 | |
62 void Done() override {} | |
63 | |
64 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* requests; | |
65 BlobDataBuilder* builder; | |
66 | |
67 size_t current_storage_item; | |
68 }; | |
69 | |
70 // This class handles the logic of storing memory that is transported as | |
71 // consolidated shared memory. The main hurdle is to re-separate memory blocks | |
72 // that cross file or blob boundaries. | |
michaeln
2015/11/21 00:59:45
when are blob boundaries crossed?
dmurph
2015/11/23 20:07:02
Blob reference boundaries.
| |
73 class SharedMemoryStorageStrategy | |
74 : public BlobAsyncTransportStrategy::BlobSegmentVisitor<size_t> { | |
75 public: | |
76 typedef size_t SizeType; | |
77 | |
78 SharedMemoryStorageStrategy( | |
79 SizeType max_segment_size, | |
80 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* | |
81 requests, | |
82 BlobDataBuilder* builder) | |
83 : requests(requests), | |
84 max_segment_size(max_segment_size), | |
85 storage_element_offset(0), | |
86 builder(builder), | |
87 current_item_size(0), | |
88 current_storage_item(0) {} | |
89 ~SharedMemoryStorageStrategy() override {} | |
90 | |
91 void VisitBytesSegment(size_t element_index, | |
92 SizeType element_offset, | |
93 size_t segment_index, | |
94 SizeType segment_offset, | |
95 SizeType size) override { | |
96 if (storage_element_offset + size > max_segment_size) { | |
97 builder->AppendFutureData(current_item_size); | |
98 current_storage_item++; | |
99 current_item_size = 0; | |
100 storage_element_offset = 0; | |
101 } | |
102 BlobAsyncTransportStrategy::RendererMemoryItemRequest request; | |
103 request.browser_item_index = current_storage_item; | |
104 request.browser_item_offset = storage_element_offset; | |
105 request.message.request_number = requests->size(); | |
106 request.message.transport_strategy = | |
107 IPCBlobItemRequestStrategy::SHARED_MEMORY; | |
108 request.message.renderer_item_index = element_index; | |
109 request.message.renderer_item_offset = element_offset; | |
110 request.message.size = size; | |
111 request.message.handle_index = segment_index; | |
112 request.message.handle_offset = segment_offset; | |
113 | |
114 requests->push_back(request); | |
115 storage_element_offset += size; | |
116 current_item_size += size; | |
117 }; | |
118 | |
119 void VisitNonBytesSegment(const DataElement& element, | |
120 size_t element_index) override { | |
121 builder->AppendFutureData(current_item_size); | |
michaeln
2015/11/21 00:59:45
what if current_item_size is 0?
dmurph
2015/11/23 20:07:02
Fixed, and added test.
| |
122 current_storage_item++; | |
123 builder->AppendIPCDataElement(element); | |
124 current_storage_item++; | |
125 storage_element_offset = 0; | |
126 current_item_size = 0; | |
127 } | |
128 | |
129 void Done() override { | |
130 if (current_item_size != 0) { | |
131 builder->AppendFutureData(current_item_size); | |
132 } | |
133 } | |
134 | |
135 std::vector<BlobAsyncTransportStrategy::RendererMemoryItemRequest>* requests; | |
136 | |
137 SizeType max_segment_size; | |
138 SizeType storage_element_offset; | |
139 BlobDataBuilder* builder; | |
140 SizeType current_item_size; | |
141 size_t current_storage_item; | |
michaeln
2015/11/21 00:59:45
naminga this as current_item_index might help
| |
142 }; | |
143 | |
144 BlobAsyncTransportStrategy::RendererMemoryItemRequest:: | |
145 RendererMemoryItemRequest() | |
146 : browser_item_index(0), browser_item_offset(0), received(false) {} | |
147 | |
148 BlobAsyncTransportStrategy::BlobAsyncTransportStrategy() | |
149 : error_(BlobAsyncTransportStrategy::ERROR_NONE), total_bytes_size_(0) {} | |
150 | |
151 BlobAsyncTransportStrategy::~BlobAsyncTransportStrategy() {} | |
152 | |
153 // if total_blob_size > kMaxBlobSize (say 400MB) | |
154 // Request all data in files | |
155 // (Segment all of the existing data into | |
156 // file blocks, of <= kMaxFileSize) | |
157 // else if total_blob_size > kMaxIPCSize (this is 150KB) | |
158 // Request all data in shared memory | |
159 // (Segment all of the existing data into | |
160 // shared memory blocks, of <= kMaxSharedMemorySize) | |
161 // else | |
162 // Request all data to be sent over IPC | |
163 void BlobAsyncTransportStrategy::Initialize( | |
michaeln
2015/11/21 00:59:45
this method reads a lot nicer now, thnx!
| |
164 size_t max_ipc_memory_size, | |
165 size_t max_shared_memory_size, | |
166 uint64_t max_file_size, | |
167 uint64_t disk_space_left, | |
168 size_t memory_available, | |
169 const std::string& uuid, | |
170 const std::vector<DataElement>& blob_item_infos) { | |
171 file_handle_sizes_.clear(); | |
172 shared_memory_handle_sizes_.clear(); | |
173 requests_.clear(); | |
174 builder_.reset(new BlobDataBuilder(uuid)); | |
175 error_ = BlobAsyncTransportStrategy::ERROR_NONE; | |
kinuko
2015/11/20 15:19:42
I think I've once asked this but is an instance of
dmurph
2015/11/20 22:10:05
Sounds good, I'll add DCHECKs then.
| |
176 | |
177 size_t memory_items = 0; | |
178 total_bytes_size_ = 0; | |
179 for (const auto& info : blob_item_infos) { | |
180 if (!IsBytes(info.type())) { | |
181 continue; | |
182 } | |
183 total_bytes_size_ += info.length(); | |
184 ++memory_items; | |
185 } | |
186 | |
187 // See if we have enough memory | |
188 if (total_bytes_size_ > | |
189 disk_space_left + static_cast<uint64_t>(memory_available)) { | |
190 error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE; | |
191 return; | |
192 } | |
193 | |
194 // If we're more than the available memory, then we're going straight to disk. | |
195 if (total_bytes_size_ > memory_available) { | |
196 // First, handle the case where we go to disk. | |
michaeln
2015/11/21 00:59:45
redundant comment?
dmurph
2015/11/23 20:07:02
Done.
| |
197 if (total_bytes_size_ < disk_space_left) { | |
198 ComputeHandleSizes(total_bytes_size_, max_file_size, &file_handle_sizes_); | |
199 FileStorageStrategy strategy(&requests_, builder_.get()); | |
200 ForEachWithSegment(blob_item_infos, max_file_size, &strategy); | |
201 return; | |
202 } | |
203 error_ = BlobAsyncTransportStrategy::ERROR_TOO_LARGE; | |
204 return; | |
kinuko
2015/11/20 15:19:42
nit: prefer early return (handle error case first)
dmurph
2015/11/20 22:10:05
Done.
| |
205 } | |
206 | |
207 if (total_bytes_size_ > max_ipc_memory_size) { | |
208 CHECK_LE(total_bytes_size_, std::numeric_limits<size_t>::max()); | |
209 ComputeHandleSizes(static_cast<size_t>(total_bytes_size_), | |
210 max_shared_memory_size, &shared_memory_handle_sizes_); | |
211 SharedMemoryStorageStrategy strategy(max_shared_memory_size, &requests_, | |
212 builder_.get()); | |
213 ForEachWithSegment(blob_item_infos, max_shared_memory_size, &strategy); | |
214 return; | |
215 } | |
kinuko
2015/11/20 15:19:42
nit: let's add one empty line here
dmurph
2015/11/20 22:10:05
Done.
| |
216 // Since they can all fit in IPC memory, we don't need to segment anything, | |
217 // and just request them straight in IPC. | |
218 size_t items_length = blob_item_infos.size(); | |
219 for (size_t i = 0; i < items_length; i++) { | |
220 const auto& info = blob_item_infos.at(i); | |
221 if (!IsBytes(info.type())) { | |
222 builder_->AppendIPCDataElement(info); | |
223 continue; | |
224 } | |
225 BlobAsyncTransportStrategy::RendererMemoryItemRequest request; | |
226 request.browser_item_index = i; | |
227 request.browser_item_offset = 0; | |
228 request.message.request_number = requests_.size(); | |
229 request.message.transport_strategy = IPCBlobItemRequestStrategy::IPC; | |
230 request.message.renderer_item_index = i; | |
231 request.message.renderer_item_offset = 0; | |
232 request.message.size = info.length(); | |
233 requests_.push_back(request); | |
234 builder_->AppendFutureData(info.length()); | |
235 } | |
236 } | |
237 | |
238 // Splits each |element| into one or more |segments| of a max_size, invokes the | |
239 // strategy to determine the request to make for each |segment| produced. A | |
240 // |segment| can also span multiple |elements|. | |
241 /* static */ | |
242 template <typename SizeType> | |
243 void BlobAsyncTransportStrategy::ForEachWithSegment( | |
244 const std::vector<DataElement>& elements, | |
245 SizeType max_segment_size, | |
246 BlobSegmentVisitor<SizeType>* visitor) { | |
247 DCHECK_GT(max_segment_size, 0ull); | |
248 size_t segment_index = 0; | |
249 SizeType segment_offset = 0; | |
250 size_t elements_length = elements.size(); | |
251 for (size_t element_index = 0; element_index < elements_length; | |
252 ++element_index) { | |
253 const auto& element = elements.at(element_index); | |
254 DataElement::Type type = element.type(); | |
255 if (!IsBytes(type)) { | |
256 visitor->VisitNonBytesSegment(element, element_index); | |
257 continue; | |
258 } | |
259 SizeType element_memory_left = element.length(); | |
260 SizeType element_offset = 0; | |
261 while (element_memory_left > 0) { | |
262 if (segment_offset == max_segment_size) { | |
263 ++segment_index; | |
264 segment_offset = 0; | |
265 } | |
266 SizeType memory_writing = | |
267 std::min(max_segment_size - segment_offset, element_memory_left); | |
268 visitor->VisitBytesSegment(element_index, element_offset, segment_index, | |
269 segment_offset, memory_writing); | |
270 element_memory_left -= memory_writing; | |
271 segment_offset += memory_writing; | |
272 element_offset += memory_writing; | |
273 } | |
274 } | |
275 visitor->Done(); | |
276 } | |
277 | |
278 /* static */ | |
279 bool BlobAsyncTransportStrategy::ShouldBeShortcut( | |
280 const std::vector<DataElement>& elements, | |
281 size_t memory_available) { | |
282 size_t shortcut_bytes = 0; | |
283 for (const auto& element : elements) { | |
284 DataElement::Type type = element.type(); | |
285 if (type == DataElement::TYPE_BYTES_DESCRIPTION) { | |
286 return false; | |
287 } | |
288 if (type == DataElement::TYPE_BYTES) { | |
289 shortcut_bytes += element.length(); | |
290 } | |
291 } | |
292 return shortcut_bytes <= memory_available; | |
293 } | |
294 | |
295 /* static */ | |
296 template <typename SizeType> | |
297 void BlobAsyncTransportStrategy::ComputeHandleSizes( | |
298 SizeType total_memory_size, | |
299 SizeType max_segment_size, | |
300 std::vector<SizeType>* segment_sizes) { | |
kinuko
2015/11/20 15:19:42
nit: probably resize the segment_sizes first befor
dmurph
2015/11/20 22:10:05
Done.
dmurph
2015/11/20 22:10:05
Done.
| |
301 segment_sizes->insert(segment_sizes->begin(), | |
302 total_memory_size / max_segment_size, max_segment_size); | |
303 if (total_memory_size % max_segment_size > 0) { | |
304 segment_sizes->push_back(total_memory_size % max_segment_size); | |
305 } | |
306 } | |
307 | |
308 } // namespace storage | |
OLD | NEW |