| /xsrc/external/mit/MesaLib.old/dist/src/gallium/drivers/iris/ |
| iris_pipe_control.c | 152 struct iris_batch *render_batch = &ice->batches[IRIS_BATCH_RENDER];
153 struct iris_batch *compute_batch = &ice->batches[IRIS_BATCH_COMPUTE];
158 iris_emit_pipe_control_flush(&ice->batches[IRIS_BATCH_RENDER],
162 iris_emit_pipe_control_flush(&ice->batches[IRIS_BATCH_RENDER],
167 iris_emit_pipe_control_flush(&ice->batches[IRIS_BATCH_COMPUTE],
169 iris_emit_pipe_control_flush(&ice->batches[IRIS_BATCH_COMPUTE],
197 if (ice->batches[i].contains_draw ||
198 ice->batches[i].cache.render->entries)
199 iris_emit_pipe_control_flush(&ice->batches[i], bits);
|
| iris_context.c | 121 iris_batch_free(&ice->batches[IRIS_BATCH_RENDER]);
122 iris_batch_free(&ice->batches[IRIS_BATCH_COMPUTE]);
214 iris_init_batch(&ice->batches[i], screen, &ice->vtbl, &ice->dbg,
215 ice->batches, (enum iris_batch_name) i,
219 ice->vtbl.init_render_context(screen, &ice->batches[IRIS_BATCH_RENDER],
221 ice->vtbl.init_compute_context(screen, &ice->batches[IRIS_BATCH_COMPUTE],
|
| iris_border_color.c | 106 * batches that are referring to the old BO and makes a new one.
118 if (iris_batch_references(&ice->batches[i], pool->bo))
119 iris_batch_flush(&ice->batches[i]);
|
| iris_fence.c | 168 iris_batch_flush(&ice->batches[i]);
180 if (!iris_wait_syncpt(ctx->screen, ice->batches[b].last_syncpt, 0))
184 ice->batches[b].last_syncpt);
197 iris_batch_add_syncpt(&ice->batches[b], fence->syncpt[i],
|
| iris_query.c | 164 struct iris_batch *batch = &ice->batches[q->batch_idx];
200 struct iris_batch *batch = &ice->batches[q->batch_idx];
222 iris_pipelined_write(&ice->batches[IRIS_BATCH_RENDER], q,
230 iris_pipelined_write(&ice->batches[IRIS_BATCH_RENDER], q,
272 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
521 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
544 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
572 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
599 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
622 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER]
[all...] |
| /xsrc/external/mit/MesaLib/dist/src/gallium/drivers/freedreno/ |
| freedreno_batch_cache.c | 63 * So each resource holds a hashset of batches which have reference them
144 /* Flushes all batches in the batch cache. Used at glFlush() and similar times. */
151 * can cause batches to be unref'd and freed under our feet, so grab
152 * a reference to all the batches we need up-front.
154 struct fd_batch *batches[ARRAY_SIZE(cache->batches)] = {0}; variable in typeref:struct:fd_batch
162 fd_batch_reference_locked(&batches[n++], batch);
168 * batch. So when the current batch gets flushed, all other batches
175 if (batches[i] && (batches[i]->ctx == ctx) &
188 fd_batch_flush(batches[i]); variable
221 struct fd_batch *batch, *batches[32] = {}; variable in typeref:struct:
235 fd_batch_flush(batches[i]); variable
[all...] |
| freedreno_batch_cache.h | 45 /* set of active batches.. there is an upper limit on the number of
46 * in-flight batches, for two reasons:
47 * 1) to avoid big spikes in number of batches in edge cases, such as
51 * batches have reference to the resource
53 struct fd_batch *batches[32]; member in struct:fd_batch_cache
57 /* note: if batches get unref'd in the body of the loop, they are removed
64 _m && ((batch) = (cache)->batches[u_bit_scan(&_m)]); _m &= (mask))
|
| /xsrc/external/mit/MesaLib.old/dist/src/gallium/drivers/freedreno/ |
| freedreno_batch_cache.h | 42 /* set of active batches.. there is an upper limit on the number of
43 * in-flight batches, for two reasons:
44 * 1) to avoid big spikes in number of batches in edge cases, such as
48 * batches have reference to the resource
50 struct fd_batch *batches[32]; member in struct:fd_batch_cache
54 /* note: if batches get unref'd in the body of the loop, they are removed
60 for (uint32_t _m = (mask); _m && ((batch) = (cache)->batches[u_bit_scan(&_m)]); _m &= (mask))
|
| freedreno_batch_cache.c | 61 * So each resource holds a hashset of batches which have reference them
132 * can cause batches to be unref'd and freed under our feet, so grab
133 * a reference to all the batches we need up-front.
135 struct fd_batch *batches[ARRAY_SIZE(cache->batches)] = {0}; local
143 fd_batch_reference_locked(&batches[n++], batch);
151 if (batches[i] && (batches[i]->ctx == ctx) &&
152 (batches[i] != current_batch)) {
153 fd_batch_add_dep(current_batch, batches[i])
[all...] |
| /xsrc/external/mit/MesaLib/dist/src/gallium/drivers/crocus/ |
| crocus_pipe_control.c | 299 struct crocus_batch *render_batch = &ice->batches[CROCUS_BATCH_RENDER];
300 struct crocus_batch *compute_batch = &ice->batches[CROCUS_BATCH_COMPUTE];
336 const struct intel_device_info *devinfo = &ice->batches[0].screen->devinfo;
363 if (ice->batches[i].contains_draw) {
364 crocus_batch_maybe_flush(&ice->batches[i], 24);
365 crocus_emit_pipe_control_flush(&ice->batches[i], "API: memory barrier",
|
| crocus_context.c | 117 crocus_batch_check_for_reset(&ice->batches[i]);
205 crocus_batch_free(&ice->batches[CROCUS_BATCH_RENDER]);
206 if (ice->batches[CROCUS_BATCH_COMPUTE].ice)
207 crocus_batch_free(&ice->batches[CROCUS_BATCH_COMPUTE]);
318 screen->vtbl.init_render_context(&ice->batches[CROCUS_BATCH_RENDER]);
320 screen->vtbl.init_compute_context(&ice->batches[CROCUS_BATCH_COMPUTE]);
|
| crocus_fence.c | 116 * to stale render batches that are no longer of interest, so we can free
220 crocus_batch_flush(&ice->batches[i]);
236 struct crocus_batch *batch = &ice->batches[b];
276 struct crocus_batch *batch = &ice->batches[b];
341 if (fine->syncobj == crocus_batch_get_signal_syncobj(&ice->batches[i]))
342 crocus_batch_flush(&ice->batches[i]);
451 * batches had already completed, their syncobj's had been signalled,
550 ice->batches[b].contains_fence_signal = true;
551 crocus_batch_add_syncobj(&ice->batches[b], fine->syncobj,
|
| crocus_monitor.c | 130 crocus_emit_pipe_control_flush(&ice->batches[CROCUS_BATCH_RENDER],
142 struct crocus_batch *batch = &ice->batches[CROCUS_BATCH_RENDER];
151 _crocus_batch_flush(&ice->batches[CROCUS_BATCH_RENDER], __FILE__, __LINE__);
161 struct crocus_batch *batch = &ice->batches[CROCUS_BATCH_RENDER];
170 struct crocus_batch *batch = &ice->batches[CROCUS_BATCH_RENDER];
319 ice->batches[CROCUS_BATCH_RENDER].hw_ctx_id,
434 struct crocus_batch *batch = &ice->batches[CROCUS_BATCH_RENDER];
|
| /xsrc/external/mit/MesaLib.old/dist/src/mesa/main/ |
| glthread.c | 90 glthread->batches[i].ctx = ctx;
91 util_queue_fence_init(&glthread->batches[i].fence);
119 util_queue_fence_destroy(&glthread->batches[i].fence);
152 struct glthread_batch *next = &glthread->batches[glthread->next];
176 * Waits for all pending batches have been unmarshaled.
196 struct glthread_batch *last = &glthread->batches[glthread->last];
197 struct glthread_batch *next = &glthread->batches[glthread->next];
215 /* It's not a sync because we don't enqueue partial batches, but
|
| glthread.h | 41 * waiting batches. There must be at least 1 slot for a waiting batch,
42 * so the minimum number of batches is 3.
77 /** The ring of batches in memory. */
78 struct glthread_batch batches[MARSHAL_MAX_BATCHES]; member in struct:glthread_state
|
| marshal.h | 56 struct glthread_batch *next = &glthread->batches[glthread->next];
62 next = &glthread->batches[glthread->next];
|
| /xsrc/external/mit/MesaLib/dist/src/gallium/drivers/d3d12/ |
| d3d12_context.h | 159 struct d3d12_batch batches[4]; member in struct:d3d12_context
245 assert(ctx->current_batch_idx < ARRAY_SIZE(ctx->batches));
246 return ctx->batches + ctx->current_batch_idx;
250 unsigned oldest = (ctx->current_batch_idx + 1) % ARRAY_SIZE(ctx->batches); \
251 while (ctx->batches[oldest].fence == NULL && oldest != ctx->current_batch_idx) \
252 oldest = (oldest + 1) % ARRAY_SIZE(ctx->batches); \
253 struct d3d12_batch *batch = &ctx->batches[oldest]; \
255 oldest = (oldest + 1) % ARRAY_SIZE(ctx->batches), \
256 batch = &ctx->batches[oldest])
|
| /xsrc/external/mit/MesaLib/dist/src/gallium/drivers/iris/ |
| iris_perf.c | 35 iris_emit_end_of_pipe_sync(&ice->batches[IRIS_BATCH_RENDER],
47 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
55 _iris_batch_flush(&ice->batches[IRIS_BATCH_RENDER], __FILE__, __LINE__);
64 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
|
| iris_pipe_control.c | 170 * that any data dependencies between batches are satisfied.
173 * for concurrent updates from other batches, we provide the guarantee that a
311 struct iris_batch *render_batch = &ice->batches[IRIS_BATCH_RENDER];
312 struct iris_batch *compute_batch = &ice->batches[IRIS_BATCH_COMPUTE];
361 if (ice->batches[i].contains_draw) {
362 iris_batch_maybe_flush(&ice->batches[i], 24);
363 iris_emit_pipe_control_flush(&ice->batches[i], "API: memory barrier",
|
| iris_border_color.c | 106 * batches that are referring to the old BO and makes a new one.
118 if (iris_batch_references(&ice->batches[i], pool->bo))
119 iris_batch_flush(&ice->batches[i]);
|
| iris_performance_query.c | 79 ice->batches[IRIS_BATCH_RENDER].hw_ctx_id,
196 intel_perf_wait_query(perf_ctx, obj, &ice->batches[IRIS_BATCH_RENDER]);
213 &ice->batches[IRIS_BATCH_RENDER]);
229 intel_perf_get_query_data(perf_ctx, obj, &ice->batches[IRIS_BATCH_RENDER],
|
| iris_fence.c | 135 * to stale render batches that are no longer of interest, so we can free
267 iris_batch_flush(&ice->batches[i]);
287 struct iris_batch *batch = &ice->batches[b];
340 struct iris_batch *batch = &ice->batches[b];
408 if (fine->syncobj == iris_batch_get_signal_syncobj(&ice->batches[i]))
409 iris_batch_flush(&ice->batches[i]);
502 * batches had already completed, their syncobj's had been signalled,
603 ice->batches[b].contains_fence_signal = true;
604 iris_batch_add_syncobj(&ice->batches[b], fine->syncobj,
|
| iris_context.c | 103 iris_batch_check_for_reset(&ice->batches[i]);
243 iris_batch_free(&ice->batches[IRIS_BATCH_RENDER]);
244 iris_batch_free(&ice->batches[IRIS_BATCH_COMPUTE]);
369 screen->vtbl.init_render_context(&ice->batches[IRIS_BATCH_RENDER]);
370 screen->vtbl.init_compute_context(&ice->batches[IRIS_BATCH_COMPUTE]);
|
| /xsrc/external/mit/MesaLib/dist/src/mesa/main/ |
| glthread.c | 76 unsigned batch_index = batch - ctx->GLThread.batches;
120 glthread->batches[i].ctx = ctx;
121 util_queue_fence_init(&glthread->batches[i].fence);
123 glthread->next_batch = &glthread->batches[glthread->next];
171 util_queue_fence_destroy(&glthread->batches[i].fence);
256 glthread->next_batch = &glthread->batches[glthread->next];
261 * Waits for all pending batches have been unmarshaled.
281 struct glthread_batch *last = &glthread->batches[glthread->last];
302 /* It's not a sync because we don't enqueue partial batches, but
|
| /xsrc/external/mit/MesaLib/dist/src/gallium/drivers/panfrost/ |
| pan_job.c | 44 BITSET_FOREACH_SET(idx, ctx->batches.active, PAN_MAX_BATCHES)
49 return batch - batch->ctx->batches.slots;
74 batch->seqnum = ++ctx->batches.seqnum;
149 BITSET_CLEAR(ctx->batches.active, batch_idx);
164 if (ctx->batches.slots[i].seqnum &&
165 util_framebuffer_state_equal(&ctx->batches.slots[i].key, key)) {
169 ctx->batches.slots[i].seqnum = ++ctx->batches.seqnum;
170 return &ctx->batches.slots[i];
173 if (!batch || batch->seqnum > ctx->batches.slots[i].seqnum
[all...] |
