static void
save_reusable_variables(nir_builder *b, lower_ngg_nogs_state *nogs_state)
{
- ASSERTED int vec_ok = u_vector_init(&nogs_state->saved_uniforms, sizeof(saved_uniform), 4 * sizeof(saved_uniform));
+ ASSERTED int vec_ok = u_vector_init(&nogs_state->saved_uniforms, 4, sizeof(saved_uniform));
assert(vec_ok);
nir_block *block = nir_start_block(b->impl);
STATIC_ASSERT(sizeof(struct test_entry) == 64);
struct u_vector test_entries;
- u_vector_init(&test_entries, sizeof(struct test_entry), 4096);
+ u_vector_init_pow2(&test_entries, 64, sizeof(struct test_entry));
for (unsigned i = 0; i < ARRAY_SIZE(testcases); ++i) {
struct radeon_info info = get_radeon_info(&testcases[i]);
{
struct u_vector dead_flrp;
- if (!u_vector_init(&dead_flrp, sizeof(struct nir_alu_instr *), 64))
+ if (!u_vector_init_pow2(&dead_flrp, 8, sizeof(struct nir_alu_instr *)))
return false;
nir_foreach_function(function, shader) {
return NULL;
}
- if (!u_vector_init(&bi->instructions,
- sizeof(nir_alu_instr *),
- 8 * sizeof(nir_alu_instr *))) {
+ if (!u_vector_init_pow2(&bi->instructions, 8, sizeof(nir_alu_instr *))) {
free(bi);
return NULL;
}
if (!wl)
return NULL;
- if (!u_vector_init(&wl->instr_vec, sizeof(struct nir_instr *),
- sizeof(struct nir_instr *) * 8)) {
+ if (!u_vector_init_pow2(&wl->instr_vec, 8, sizeof(struct nir_instr *))) {
free(wl);
return NULL;
}
if (!dri2_dpy->wl_modifiers)
goto cleanup;
for (int i = 0; i < ARRAY_SIZE(dri2_wl_visuals); i++) {
- if (!u_vector_init(&dri2_dpy->wl_modifiers[i], sizeof(uint64_t), 32))
+ if (!u_vector_init_pow2(&dri2_dpy->wl_modifiers[i], 4, sizeof(uint64_t)))
goto cleanup;
}
goto fail_fd;
}
- if (!u_vector_init(&table->cleanups,
- round_to_power_of_two(sizeof(struct anv_state_table_cleanup)),
- 128)) {
+ if (!u_vector_init(&table->cleanups, 8,
+ sizeof(struct anv_state_table_cleanup))) {
result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
goto fail_fd;
}
pool->bo = &pool->wrapper_bo;
}
- if (!u_vector_init(&pool->mmap_cleanups,
- round_to_power_of_two(sizeof(struct anv_mmap_cleanup)),
- 128)) {
+ if (!u_vector_init(&pool->mmap_cleanups, 8,
+ sizeof(struct anv_mmap_cleanup))) {
result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
goto fail_fd;
}
anv_batch_bo_start(batch_bo, &cmd_buffer->batch,
GFX8_MI_BATCH_BUFFER_START_length * 4);
- int success = u_vector_init(&cmd_buffer->seen_bbos,
- sizeof(struct anv_bo *),
- 8 * sizeof(struct anv_bo *));
+ int success = u_vector_init_pow2(&cmd_buffer->seen_bbos, 8,
+ sizeof(struct anv_bo *));
if (!success)
goto fail_batch_bo;
*(struct anv_batch_bo **)u_vector_add(&cmd_buffer->seen_bbos) = batch_bo;
- /* u_vector requires power-of-two size elements */
- unsigned pow2_state_size = util_next_power_of_two(sizeof(struct anv_state));
- success = u_vector_init(&cmd_buffer->bt_block_states,
- pow2_state_size, 8 * pow2_state_size);
+ success = u_vector_init(&cmd_buffer->bt_block_states, 8,
+ sizeof(struct anv_state));
if (!success)
goto fail_seen_bbos;
uint32_t add_counter = 0;
uint32_t remove_counter = 0;
- ASSERT_TRUE(u_vector_init(&vector, sizeof(uint64_t), sizeof(uint64_t) * size_in_elements));
+ ASSERT_TRUE(u_vector_init(&vector, size_in_elements, sizeof(uint64_t)));
// Override the head and tail so we can quickly test rollover
vector.head = vector.tail = start;
* wraparound.
*/
+/**
+ * initial_element_count and element_size must be power-of-two.
+ */
int
-u_vector_init(struct u_vector *vector, uint32_t element_size, uint32_t size)
+u_vector_init_pow2(struct u_vector *vector,
+ uint32_t initial_element_count,
+ uint32_t element_size)
{
- assert(util_is_power_of_two_nonzero(size));
- assert(element_size < size && util_is_power_of_two_nonzero(element_size));
+ assert(util_is_power_of_two_nonzero(initial_element_count));
+ assert(util_is_power_of_two_nonzero(element_size));
vector->head = 0;
vector->tail = 0;
vector->element_size = element_size;
- vector->size = size;
- vector->data = malloc(size);
+ vector->size = element_size * initial_element_count;
+ vector->data = malloc(vector->size);
return vector->data != NULL;
}
#include <stdint.h>
#include <stdlib.h>
#include "util/macros.h"
+#include "util/u_math.h"
#ifdef __cplusplus
extern "C" {
void *data;
};
-int u_vector_init(struct u_vector *queue, uint32_t element_size, uint32_t size);
+int u_vector_init_pow2(struct u_vector *queue,
+ uint32_t initial_element_count,
+ uint32_t element_size);
+
void *u_vector_add(struct u_vector *queue);
void *u_vector_remove(struct u_vector *queue);
static inline int
+u_vector_init(struct u_vector *queue,
+ uint32_t initial_element_count,
+ uint32_t element_size)
+{
+ initial_element_count = util_next_power_of_two(initial_element_count);
+ element_size = util_next_power_of_two(element_size);
+ return u_vector_init_pow2(queue, initial_element_count, element_size);
+}
+
+static inline int
u_vector_length(struct u_vector *queue)
{
return (queue->head - queue->tail) / queue->element_size;
{
int ret;
- uint32_t length_pow2 = 4;
- while (length_pow2 < length)
- length_pow2 *= 2;
+ if (length < 4)
+ length = 4;
- ret = u_vector_init(&queue->vector, sizeof(uint32_t),
- sizeof(uint32_t) * length_pow2);
+ ret = u_vector_init(&queue->vector, length, sizeof(uint32_t));
if (!ret)
return ENOMEM;
return NULL;
struct u_vector modifiers;
- if (!u_vector_init(&modifiers, sizeof(uint64_t), 32))
+ if (!u_vector_init_pow2(&modifiers, 4, sizeof(uint64_t)))
return NULL;
f = u_vector_add(formats);
VkResult result = VK_SUCCESS;
memset(display, 0, sizeof(*display));
- const size_t elem_size =
- util_next_power_of_two(sizeof(struct wsi_wl_format));
- if (!u_vector_init(&display->formats, elem_size, 8 * elem_size))
+ if (!u_vector_init(&display->formats, 8, sizeof(struct wsi_wl_format)))
return VK_ERROR_OUT_OF_HOST_MEMORY;
display->wsi_wl = wsi_wl;