1 /**************************************************************************
2 *
3 * Copyright 2009 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /* Helper utility for uploading user buffers & other data, and
29 * coalescing small buffers into larger ones.
30 */
31
32 #include "pipe/p_defines.h"
33 #include "util/u_inlines.h"
34 #include "pipe/p_context.h"
35 #include "util/u_memory.h"
36 #include "util/u_math.h"
37
38 #include "u_upload_mgr.h"
39
40
41 struct u_upload_mgr {
42 struct pipe_context *pipe;
43
44 unsigned default_size; /* Minimum size of the upload buffer, in bytes. */
45 unsigned bind; /* Bitmask of PIPE_BIND_* flags. */
46 enum pipe_resource_usage usage;
47 unsigned map_flags; /* Bitmask of PIPE_TRANSFER_* flags. */
48 boolean map_persistent; /* If persistent mappings are supported. */
49
50 struct pipe_resource *buffer; /* Upload buffer. */
51 struct pipe_transfer *transfer; /* Transfer object for the upload buffer. */
52 uint8_t *map; /* Pointer to the mapped upload buffer. */
53 unsigned offset; /* Aligned offset to the upload buffer, pointing
54 * at the first unused byte. */
55 };
56
57
58 struct u_upload_mgr *
u_upload_create(struct pipe_context * pipe,unsigned default_size,unsigned bind,enum pipe_resource_usage usage)59 u_upload_create(struct pipe_context *pipe, unsigned default_size,
60 unsigned bind, enum pipe_resource_usage usage)
61 {
62 struct u_upload_mgr *upload = CALLOC_STRUCT( u_upload_mgr );
63 if (!upload)
64 return NULL;
65
66 upload->pipe = pipe;
67 upload->default_size = default_size;
68 upload->bind = bind;
69 upload->usage = usage;
70
71 upload->map_persistent =
72 pipe->screen->get_param(pipe->screen,
73 PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT);
74
75 if (upload->map_persistent) {
76 upload->map_flags = PIPE_TRANSFER_WRITE |
77 PIPE_TRANSFER_PERSISTENT |
78 PIPE_TRANSFER_COHERENT;
79 }
80 else {
81 upload->map_flags = PIPE_TRANSFER_WRITE |
82 PIPE_TRANSFER_UNSYNCHRONIZED |
83 PIPE_TRANSFER_FLUSH_EXPLICIT;
84 }
85
86 return upload;
87 }
88
89
upload_unmap_internal(struct u_upload_mgr * upload,boolean destroying)90 static void upload_unmap_internal(struct u_upload_mgr *upload, boolean destroying)
91 {
92 if (!destroying && upload->map_persistent)
93 return;
94
95 if (upload->transfer) {
96 struct pipe_box *box = &upload->transfer->box;
97
98 if (!upload->map_persistent && (int) upload->offset > box->x) {
99 pipe_buffer_flush_mapped_range(upload->pipe, upload->transfer,
100 box->x, upload->offset - box->x);
101 }
102
103 pipe_transfer_unmap(upload->pipe, upload->transfer);
104 upload->transfer = NULL;
105 upload->map = NULL;
106 }
107 }
108
109
u_upload_unmap(struct u_upload_mgr * upload)110 void u_upload_unmap( struct u_upload_mgr *upload )
111 {
112 upload_unmap_internal(upload, FALSE);
113 }
114
115
u_upload_release_buffer(struct u_upload_mgr * upload)116 static void u_upload_release_buffer(struct u_upload_mgr *upload)
117 {
118 /* Unmap and unreference the upload buffer. */
119 upload_unmap_internal(upload, TRUE);
120 pipe_resource_reference( &upload->buffer, NULL );
121 }
122
123
u_upload_destroy(struct u_upload_mgr * upload)124 void u_upload_destroy( struct u_upload_mgr *upload )
125 {
126 u_upload_release_buffer( upload );
127 FREE( upload );
128 }
129
130
131 static void
u_upload_alloc_buffer(struct u_upload_mgr * upload,unsigned min_size)132 u_upload_alloc_buffer(struct u_upload_mgr *upload,
133 unsigned min_size)
134 {
135 struct pipe_screen *screen = upload->pipe->screen;
136 struct pipe_resource buffer;
137 unsigned size;
138
139 /* Release the old buffer, if present:
140 */
141 u_upload_release_buffer( upload );
142
143 /* Allocate a new one:
144 */
145 size = align(MAX2(upload->default_size, min_size), 4096);
146
147 memset(&buffer, 0, sizeof buffer);
148 buffer.target = PIPE_BUFFER;
149 buffer.format = PIPE_FORMAT_R8_UNORM; /* want TYPELESS or similar */
150 buffer.bind = upload->bind;
151 buffer.usage = upload->usage;
152 buffer.width0 = size;
153 buffer.height0 = 1;
154 buffer.depth0 = 1;
155 buffer.array_size = 1;
156
157 if (upload->map_persistent) {
158 buffer.flags = PIPE_RESOURCE_FLAG_MAP_PERSISTENT |
159 PIPE_RESOURCE_FLAG_MAP_COHERENT;
160 }
161
162 upload->buffer = screen->resource_create(screen, &buffer);
163 if (upload->buffer == NULL)
164 return;
165
166 /* Map the new buffer. */
167 upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer,
168 0, size, upload->map_flags,
169 &upload->transfer);
170 if (upload->map == NULL) {
171 upload->transfer = NULL;
172 pipe_resource_reference(&upload->buffer, NULL);
173 return;
174 }
175
176 upload->offset = 0;
177 }
178
179 void
u_upload_alloc(struct u_upload_mgr * upload,unsigned min_out_offset,unsigned size,unsigned alignment,unsigned * out_offset,struct pipe_resource ** outbuf,void ** ptr)180 u_upload_alloc(struct u_upload_mgr *upload,
181 unsigned min_out_offset,
182 unsigned size,
183 unsigned alignment,
184 unsigned *out_offset,
185 struct pipe_resource **outbuf,
186 void **ptr)
187 {
188 unsigned buffer_size = upload->buffer ? upload->buffer->width0 : 0;
189 unsigned offset;
190
191 min_out_offset = align(min_out_offset, alignment);
192
193 offset = align(upload->offset, alignment);
194 offset = MAX2(offset, min_out_offset);
195
196 /* Make sure we have enough space in the upload buffer
197 * for the sub-allocation.
198 */
199 if (unlikely(!upload->buffer || offset + size > buffer_size)) {
200 u_upload_alloc_buffer(upload, min_out_offset + size);
201
202 if (unlikely(!upload->buffer)) {
203 *out_offset = ~0;
204 pipe_resource_reference(outbuf, NULL);
205 *ptr = NULL;
206 return;
207 }
208
209 offset = min_out_offset;
210 buffer_size = upload->buffer->width0;
211 }
212
213 if (unlikely(!upload->map)) {
214 upload->map = pipe_buffer_map_range(upload->pipe, upload->buffer,
215 offset,
216 buffer_size - offset,
217 upload->map_flags,
218 &upload->transfer);
219 if (unlikely(!upload->map)) {
220 upload->transfer = NULL;
221 *out_offset = ~0;
222 pipe_resource_reference(outbuf, NULL);
223 *ptr = NULL;
224 return;
225 }
226
227 upload->map -= offset;
228 }
229
230 assert(offset < buffer_size);
231 assert(offset + size <= buffer_size);
232 assert(size);
233
234 /* Emit the return values: */
235 *ptr = upload->map + offset;
236 pipe_resource_reference(outbuf, upload->buffer);
237 *out_offset = offset;
238
239 upload->offset = offset + size;
240 }
241
u_upload_data(struct u_upload_mgr * upload,unsigned min_out_offset,unsigned size,unsigned alignment,const void * data,unsigned * out_offset,struct pipe_resource ** outbuf)242 void u_upload_data(struct u_upload_mgr *upload,
243 unsigned min_out_offset,
244 unsigned size,
245 unsigned alignment,
246 const void *data,
247 unsigned *out_offset,
248 struct pipe_resource **outbuf)
249 {
250 uint8_t *ptr;
251
252 u_upload_alloc(upload, min_out_offset, size, alignment,
253 out_offset, outbuf,
254 (void**)&ptr);
255 if (ptr)
256 memcpy(ptr, data, size);
257 }
258
259 /* XXX: Remove. It's basically a CPU fallback of resource_copy_region. */
u_upload_buffer(struct u_upload_mgr * upload,unsigned min_out_offset,unsigned offset,unsigned size,unsigned alignment,struct pipe_resource * inbuf,unsigned * out_offset,struct pipe_resource ** outbuf)260 void u_upload_buffer(struct u_upload_mgr *upload,
261 unsigned min_out_offset,
262 unsigned offset,
263 unsigned size,
264 unsigned alignment,
265 struct pipe_resource *inbuf,
266 unsigned *out_offset,
267 struct pipe_resource **outbuf)
268 {
269 struct pipe_transfer *transfer = NULL;
270 const char *map = NULL;
271
272 map = (const char *)pipe_buffer_map_range(upload->pipe,
273 inbuf,
274 offset, size,
275 PIPE_TRANSFER_READ,
276 &transfer);
277
278 if (!map) {
279 pipe_resource_reference(outbuf, NULL);
280 return;
281 }
282
283 if (0)
284 debug_printf("upload ptr %p ofs %d sz %d\n", map, offset, size);
285
286 u_upload_data(upload, min_out_offset, size, alignment,
287 map, out_offset, outbuf);
288 pipe_buffer_unmap( upload->pipe, transfer );
289 }
290