Lines Matching refs:cs
14 tu_cs_init(struct tu_cs *cs,
21 memset(cs, 0, sizeof(*cs));
23 cs->device = device;
24 cs->mode = mode;
25 cs->next_bo_size = initial_size;
32 tu_cs_init_external(struct tu_cs *cs, struct tu_device *device,
35 memset(cs, 0, sizeof(*cs));
37 cs->device = device;
38 cs->mode = TU_CS_MODE_EXTERNAL;
39 cs->start = cs->reserved_end = cs->cur = start;
40 cs->end = end;
48 tu_cs_init_suballoc(struct tu_cs *cs, struct tu_device *device,
54 memset(cs, 0, sizeof(*cs));
55 cs->device = device;
56 cs->mode = TU_CS_MODE_SUB_STREAM;
57 cs->start = cs->reserved_end = cs->cur = start;
58 cs->end = end;
59 cs->refcount_bo = tu_bo_get_ref(suballoc_bo->bo);
66 tu_cs_finish(struct tu_cs *cs)
68 for (uint32_t i = 0; i < cs->bo_count; ++i) {
69 tu_bo_finish(cs->device, cs->bos[i]);
72 if (cs->refcount_bo)
73 tu_bo_finish(cs->device, cs->refcount_bo);
75 free(cs->entries);
76 free(cs->bos);
80 tu_cs_current_bo(const struct tu_cs *cs)
82 if (cs->refcount_bo) {
83 return cs->refcount_bo;
85 assert(cs->bo_count);
86 return cs->bos[cs->bo_count - 1];
95 tu_cs_get_offset(const struct tu_cs *cs)
97 return cs->start - (uint32_t *) tu_cs_current_bo(cs)->map;
105 tu_cs_add_bo(struct tu_cs *cs, uint32_t size)
108 assert(cs->mode != TU_CS_MODE_EXTERNAL);
110 assert(!cs->refcount_bo);
113 assert(tu_cs_is_empty(cs));
115 /* grow cs->bos if needed */
116 if (cs->bo_count == cs->bo_capacity) {
117 uint32_t new_capacity = MAX2(4, 2 * cs->bo_capacity);
119 realloc(cs->bos, new_capacity * sizeof(struct tu_bo *));
123 cs->bo_capacity = new_capacity;
124 cs->bos = new_bos;
130 tu_bo_init_new(cs->device, &new_bo, size * sizeof(uint32_t),
136 result = tu_bo_map(cs->device, new_bo);
138 tu_bo_finish(cs->device, new_bo);
142 cs->bos[cs->bo_count++] = new_bo;
144 cs->start = cs->cur = cs->reserved_end = (uint32_t *) new_bo->map;
145 cs->end = cs->start + new_bo->size / sizeof(uint32_t);
154 tu_cs_reserve_entry(struct tu_cs *cs)
157 assert(cs->mode == TU_CS_MODE_GROW);
159 /* grow cs->entries if needed */
160 if (cs->entry_count == cs->entry_capacity) {
161 uint32_t new_capacity = MAX2(4, cs->entry_capacity * 2);
163 realloc(cs->entries, new_capacity * sizeof(struct tu_cs_entry));
167 cs->entry_capacity = new_capacity;
168 cs->entries = new_entries;
179 tu_cs_add_entry(struct tu_cs *cs)
182 assert(cs->mode == TU_CS_MODE_GROW);
185 assert(!tu_cs_is_empty(cs));
191 assert(cs->bo_count);
192 assert(cs->entry_count < cs->entry_capacity);
194 /* add an entry for [cs->start, cs->cur] */
195 cs->entries[cs->entry_count++] = (struct tu_cs_entry) {
196 .bo = tu_cs_current_bo(cs),
197 .size = tu_cs_get_size(cs) * sizeof(uint32_t),
198 .offset = tu_cs_get_offset(cs) * sizeof(uint32_t),
201 cs->start = cs->cur;
208 tu_cs_add_entries(struct tu_cs *cs, struct tu_cs *target)
212 assert(cs->mode == TU_CS_MODE_GROW);
215 if (!tu_cs_is_empty(cs))
216 tu_cs_add_entry(cs);
219 result = tu_cs_reserve_entry(cs);
222 cs->entries[cs->entry_count++] = target->entries[i];
230 * checks currently. \a cs must not be in TU_CS_MODE_SUB_STREAM mode.
233 tu_cs_begin(struct tu_cs *cs)
235 assert(cs->mode != TU_CS_MODE_SUB_STREAM);
236 assert(tu_cs_is_empty(cs));
240 * End command packet emission. This adds an IB entry when \a cs is in
244 tu_cs_end(struct tu_cs *cs)
246 assert(cs->mode != TU_CS_MODE_SUB_STREAM);
248 if (cs->mode == TU_CS_MODE_GROW && !tu_cs_is_empty(cs))
249 tu_cs_add_entry(cs);
253 * Begin command packet emission to a sub-stream. \a cs must be in
261 tu_cs_begin_sub_stream(struct tu_cs *cs, uint32_t size, struct tu_cs *sub_cs)
263 assert(cs->mode == TU_CS_MODE_SUB_STREAM);
266 VkResult result = tu_cs_reserve_space(cs, size);
270 tu_cs_init_external(sub_cs, cs->device, cs->cur, cs->reserved_end);
280 * \a cs must be in TU_CS_MODE_SUB_STREAM mode.
284 tu_cs_alloc(struct tu_cs *cs,
289 assert(cs->mode == TU_CS_MODE_SUB_STREAM);
297 VkResult result = tu_cs_reserve_space(cs, count * size + (size-1));
301 struct tu_bo *bo = tu_cs_current_bo(cs);
302 size_t offset = align(tu_cs_get_offset(cs), size);
307 cs->start = cs->cur = (uint32_t*) bo->map + offset + count * size;
317 * \a cs.
320 tu_cs_end_sub_stream(struct tu_cs *cs, struct tu_cs *sub_cs)
322 assert(cs->mode == TU_CS_MODE_SUB_STREAM);
323 assert(sub_cs->start == cs->cur && sub_cs->end == cs->reserved_end);
328 cs->cur = sub_cs->cur;
331 .bo = tu_cs_current_bo(cs),
332 .size = tu_cs_get_size(cs) * sizeof(uint32_t),
333 .offset = tu_cs_get_offset(cs) * sizeof(uint32_t),
336 cs->start = cs->cur;
343 * This never fails when \a cs has mode TU_CS_MODE_EXTERNAL.
346 tu_cs_reserve_space(struct tu_cs *cs, uint32_t reserved_size)
348 if (tu_cs_get_space(cs) < reserved_size) {
349 if (cs->mode == TU_CS_MODE_EXTERNAL) {
355 if (!tu_cs_is_empty(cs)) {
357 assert(cs->mode != TU_CS_MODE_SUB_STREAM);
359 tu_cs_add_entry(cs);
362 for (uint32_t i = 0; i < cs->cond_stack_depth; i++) {
364 *cs->cond_dwords[i] = cs->cur - cs->cond_dwords[i] - 1;
371 uint32_t new_size = MAX2(cs->next_bo_size, reserved_size);
372 VkResult result = tu_cs_add_bo(cs, new_size);
376 if (cs->cond_stack_depth) {
377 cs->reserved_end = cs->cur + reserved_size;
381 for (uint32_t i = 0; i < cs->cond_stack_depth; i++) {
382 tu_cs_emit_pkt7(cs, CP_COND_REG_EXEC, 2);
383 tu_cs_emit(cs, cs->cond_flags[i]);
385 cs->cond_dwords[i] = cs->cur;
388 tu_cs_emit(cs, CP_COND_REG_EXEC_1_DWORDS(0));
395 if (cs->next_bo_size < new_size)
396 cs->next_bo_size = new_size;
399 assert(tu_cs_get_space(cs) >= reserved_size);
400 cs->reserved_end = cs->cur + reserved_size;
402 if (cs->mode == TU_CS_MODE_GROW) {
404 return tu_cs_reserve_entry(cs);
412 * packets in \a cs, but does not necessarily release all resources.
415 tu_cs_reset(struct tu_cs *cs)
417 if (cs->mode == TU_CS_MODE_EXTERNAL) {
418 assert(!cs->bo_count && !cs->refcount_bo && !cs->entry_count);
419 cs->reserved_end = cs->cur = cs->start;
423 for (uint32_t i = 0; i + 1 < cs->bo_count; ++i) {
424 tu_bo_finish(cs->device, cs->bos[i]);
427 if (cs->bo_count) {
428 cs->bos[0] = cs->bos[cs->bo_count - 1];
429 cs->bo_count = 1;
431 cs->start = cs->cur = cs->reserved_end = (uint32_t *) cs->bos[0]->map;
432 cs->end = cs->start + cs->bos[0]->size / sizeof(uint32_t);
435 cs->entry_count = 0;