Lines Matching refs:next
11 * The above copyright notice and this permission notice (including the next
85 * At the next level we can use various sub-allocators. The state pool is a
168 table->state.next = 0;
233 uint32_t used = align_u32(table->state.next * ANV_STATE_ENTRY_SIZE,
289 if (state.next + count <= state.end) {
291 struct anv_free_entry *entry = &table->map[state.next];
293 entry[i].state.idx = state.next + i;
295 *idx = state.next;
297 } else if (state.next <= state.end) {
299 * the pool. pool_state->next acts a mutex: threads who try to
303 new.next = state.next + count;
309 } while (new.end < new.next);
312 if (old.next != state.next)
330 table->map[last].next = last + 1;
335 table->map[last].next = current.offset;
351 new.offset = table->map[current.offset].next;
418 pool->state.next = 0;
420 pool->back_state.next = 0;
640 * particular, block_pool_alloc() increments state->next prior to
647 uint32_t back_used = align_u32(pool->back_state.next, PAGE_SIZE);
648 uint32_t front_used = align_u32(pool->state.next, PAGE_SIZE);
664 * requirement because they are based on the next pointers which are
673 * properly contiguous map for the next chunk.
733 * updates state->next. Instead, we let the caller do that because it
760 if (state.next + block_size <= state.end) {
761 return state.next;
762 } else if (state.next <= state.end) {
763 if (!pool->use_relocations && state.next < state.end) {
768 uint32_t leftover = state.end - state.next;
776 state.next += leftover;
780 * the pool. pool_state->next acts a mutex: threads who try to
784 new.next = state.next + block_size;
787 } while (new.end < new.next);
790 if (old.next != state.next)
792 return state.next;
870 pool->buckets[i].block.next = 0;
912 if (block.next < block.end) {
913 return block.next;
914 } else if (block.next == block.end) {
916 new.next = offset + state_size;
919 if (old.next != block.next)
1196 /* The next block */
1197 struct anv_state_stream_block *next;
1220 /* Ensure that next + whatever > block_size. This way the first call to
1223 stream->next = block_size;
1252 uint32_t offset = align_u32(stream->next, alignment);
1265 stream->next = offset = 0;
1268 const bool new_block = stream->next == 0;
1275 stream->next = offset + size;
1284 stream->next));
1685 /* Align the size up to the next multiple of 64K so we don't have any