intel: use intel_alloc()/intel_free() when possible

There are still a few places that intel_handle is not readily available and we
are stuck with icd_alloc()/icd_free().  They will be fixed later.

diff --git a/icd/intel/cmd.c b/icd/intel/cmd.c
index 56e5b04..afdd869 100644 (file)
--- a/icd/intel/cmd.c
+++ b/icd/intel/cmd.c
@@ -58,7 +58,7 @@ static void cmd_writer_reset(struct intel_cmd *cmd,
     writer->sba_offset = 0;
 
     if (writer->items) {
-        icd_free(writer->items);
+        intel_free(cmd, writer->items);
         writer->items = NULL;
         writer->item_alloc = 0;
         writer->item_used = 0;
@@ -194,7 +194,7 @@ void cmd_writer_record(struct intel_cmd *cmd,
             writer->item_alloc << 1 : 256;
         struct intel_cmd_item *items;
 
-        items = icd_alloc(sizeof(writer->items[0]) * new_alloc,
+        items = intel_alloc(cmd, sizeof(writer->items[0]) * new_alloc,
                 0, XGL_SYSTEM_ALLOC_DEBUG);
         if (!items) {
             writer->item_used = 0;
@@ -205,7 +205,7 @@ void cmd_writer_record(struct intel_cmd *cmd,
         memcpy(items, writer->items,
                 sizeof(writer->items[0]) * writer->item_alloc);
 
-        icd_free(writer->items);
+        intel_free(cmd, writer->items);
 
         writer->items = items;
         writer->item_alloc = new_alloc;
@@ -235,12 +235,12 @@ static void cmd_reset(struct intel_cmd *cmd)
         cmd_writer_reset(cmd, i);
 
     if (cmd->bind.shader_cache.entries)
-        icd_free(cmd->bind.shader_cache.entries);
+        intel_free(cmd, cmd->bind.shader_cache.entries);
 
     if (cmd->bind.dset.graphics_dynamic_offsets)
-        icd_free(cmd->bind.dset.graphics_dynamic_offsets);
+        intel_free(cmd, cmd->bind.dset.graphics_dynamic_offsets);
     if (cmd->bind.dset.compute_dynamic_offsets)
-        icd_free(cmd->bind.dset.compute_dynamic_offsets);
+        intel_free(cmd, cmd->bind.dset.compute_dynamic_offsets);
 
     memset(&cmd->bind, 0, sizeof(cmd->bind));
 
@@ -294,7 +294,7 @@ XGL_RESULT intel_cmd_create(struct intel_dev *dev,
      * and end offsets, for each referenced memories.
      */
     cmd->reloc_count = dev->gpu->batch_buffer_reloc_count;
-    cmd->relocs = icd_alloc(sizeof(cmd->relocs[0]) * cmd->reloc_count,
+    cmd->relocs = intel_alloc(cmd, sizeof(cmd->relocs[0]) * cmd->reloc_count,
             4096, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!cmd->relocs) {
         intel_cmd_destroy(cmd);
@@ -310,7 +310,7 @@ void intel_cmd_destroy(struct intel_cmd *cmd)
 {
     cmd_reset(cmd);
 
-    icd_free(cmd->relocs);
+    intel_free(cmd, cmd->relocs);
     intel_base_destroy(&cmd->obj.base);
 }
 

diff --git a/icd/intel/cmd_pipeline.c b/icd/intel/cmd_pipeline.c
index 1fa9949..3c19b15 100644 (file)
--- a/icd/intel/cmd_pipeline.c
+++ b/icd/intel/cmd_pipeline.c
@@ -1884,13 +1884,13 @@ static uint32_t emit_shader(struct intel_cmd *cmd,
         const uint32_t count = cache->count + 16;
         void *entries;
 
-        entries = icd_alloc(sizeof(cache->entries[0]) * count, 0,
+        entries = intel_alloc(cmd, sizeof(cache->entries[0]) * count, 0,
                 XGL_SYSTEM_ALLOC_INTERNAL);
         if (entries) {
             if (cache->entries) {
                 memcpy(entries, cache->entries,
                         sizeof(cache->entries[0]) * cache->used);
-                icd_free(cache->entries);
+                intel_free(cmd, cache->entries);
             }
 
             cache->entries = entries;
@@ -2954,10 +2954,10 @@ static void cmd_bind_graphics_dset(struct intel_cmd *cmd,
 
     if (size > cmd->bind.dset.graphics_dynamic_offset_size) {
         if (cmd->bind.dset.graphics_dynamic_offsets)
-            icd_free(cmd->bind.dset.graphics_dynamic_offsets);
+            intel_free(cmd, cmd->bind.dset.graphics_dynamic_offsets);
 
-        cmd->bind.dset.graphics_dynamic_offsets = icd_alloc(size,
-                4, XGL_SYSTEM_ALLOC_INTERNAL);
+        cmd->bind.dset.graphics_dynamic_offsets = intel_alloc(cmd,
+                size, 4, XGL_SYSTEM_ALLOC_INTERNAL);
         if (!cmd->bind.dset.graphics_dynamic_offsets) {
             cmd_fail(cmd, XGL_ERROR_OUT_OF_MEMORY);
             return;
@@ -2979,10 +2979,10 @@ static void cmd_bind_compute_dset(struct intel_cmd *cmd,
 
     if (size > cmd->bind.dset.compute_dynamic_offset_size) {
         if (cmd->bind.dset.compute_dynamic_offsets)
-            icd_free(cmd->bind.dset.compute_dynamic_offsets);
+            intel_free(cmd, cmd->bind.dset.compute_dynamic_offsets);
 
-        cmd->bind.dset.compute_dynamic_offsets = icd_alloc(size,
-                4, XGL_SYSTEM_ALLOC_INTERNAL);
+        cmd->bind.dset.compute_dynamic_offsets = intel_alloc(cmd,
+                size, 4, XGL_SYSTEM_ALLOC_INTERNAL);
         if (!cmd->bind.dset.compute_dynamic_offsets) {
             cmd_fail(cmd, XGL_ERROR_OUT_OF_MEMORY);
             return;

diff --git a/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp b/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
index 016401a..edb0560 100644 (file)
--- a/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
+++ b/icd/intel/compiler/pipeline/pipeline_compiler_interface.cpp
@@ -296,7 +296,7 @@ static struct intel_pipeline_rmap *rmap_create(const struct intel_gpu *gpu,
     uint32_t surface_count, i;
 
     rmap = (struct intel_pipeline_rmap *)
-        icd_alloc(sizeof(*rmap), 0, XGL_SYSTEM_ALLOC_INTERNAL);
+        intel_alloc(gpu, sizeof(*rmap), 0, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!rmap)
         return NULL;
 
@@ -312,10 +312,10 @@ static struct intel_pipeline_rmap *rmap_create(const struct intel_gpu *gpu,
     rmap->slot_count = surface_count + rmap->sampler_count;
 
     rmap->slots = (struct intel_pipeline_rmap_slot *)
-        icd_alloc(sizeof(rmap->slots[0]) * rmap->slot_count,
+        intel_alloc(gpu, sizeof(rmap->slots[0]) * rmap->slot_count,
             0, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!rmap->slots) {
-        icd_free(rmap);
+        intel_free(gpu, rmap);
         return NULL;
     }
 
@@ -419,7 +419,7 @@ XGL_RESULT intel_pipeline_shader_compile(struct intel_pipeline_shader *pipe_shad
         {
             pipe_shader->codeSize = get_vs_program_size(brw->shader_prog);
 
-            pipe_shader->pCode = icd_alloc(pipe_shader->codeSize, 0, XGL_SYSTEM_ALLOC_INTERNAL_SHADER);
+            pipe_shader->pCode = intel_alloc(gpu, pipe_shader->codeSize, 0, XGL_SYSTEM_ALLOC_INTERNAL_SHADER);
             if (!pipe_shader->pCode) {
                 status = XGL_ERROR_OUT_OF_MEMORY;
                 break;
@@ -538,7 +538,7 @@ XGL_RESULT intel_pipeline_shader_compile(struct intel_pipeline_shader *pipe_shad
 
             pipe_shader->codeSize = get_wm_program_size(brw->shader_prog);
 
-            pipe_shader->pCode = icd_alloc(pipe_shader->codeSize, 0, XGL_SYSTEM_ALLOC_INTERNAL_SHADER);
+            pipe_shader->pCode = intel_alloc(gpu, pipe_shader->codeSize, 0, XGL_SYSTEM_ALLOC_INTERNAL_SHADER);
             if (!pipe_shader->pCode) {
                 status = XGL_ERROR_OUT_OF_MEMORY;
                 break;

diff --git a/icd/intel/desc.c b/icd/intel/desc.c
index 9869c4f..51d7beb 100644 (file)
--- a/icd/intel/desc.c
+++ b/icd/intel/desc.c
@@ -72,14 +72,14 @@ XGL_RESULT intel_desc_pool_create(struct intel_dev *dev,
     const uint32_t sampler_count = 16384;
     struct intel_desc_pool *pool;
 
-    pool = icd_alloc(sizeof(*pool), 0, XGL_SYSTEM_ALLOC_INTERNAL);
+    pool = intel_alloc(dev, sizeof(*pool), 0, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!pool)
         return XGL_ERROR_OUT_OF_MEMORY;
 
     memset(pool, 0, sizeof(*pool));
 
     if (!desc_pool_init_desc_sizes(pool, dev->gpu)) {
-        icd_free(pool);
+        intel_free(dev, pool);
         return XGL_ERROR_UNKNOWN;
     }
 
@@ -87,18 +87,18 @@ XGL_RESULT intel_desc_pool_create(struct intel_dev *dev,
             pool->surface_desc_size * surface_count,
             pool->sampler_desc_size * sampler_count);
 
-    pool->surfaces = icd_alloc(pool->size.surface,
+    pool->surfaces = intel_alloc(dev, pool->size.surface,
             64, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!pool->surfaces) {
-        icd_free(pool);
+        intel_free(dev, pool);
         return XGL_ERROR_OUT_OF_MEMORY;
     }
 
-    pool->samplers = icd_alloc(pool->size.sampler,
+    pool->samplers = intel_alloc(dev, pool->size.sampler,
             64, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!pool->samplers) {
-        icd_free(pool->surfaces);
-        icd_free(pool);
+        intel_free(dev, pool->surfaces);
+        intel_free(dev, pool);
         return XGL_ERROR_OUT_OF_MEMORY;
     }
 
@@ -712,7 +712,7 @@ static XGL_RESULT desc_layout_alloc_ranges(struct intel_desc_layout *layout,
         info = info->pNext;
     }
 
-    layout->ranges = icd_alloc(sizeof(layout->ranges[0]) *
+    layout->ranges = intel_alloc(layout, sizeof(layout->ranges[0]) *
             layout->range_count, 0, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!layout->ranges)
         return XGL_ERROR_OUT_OF_MEMORY;
@@ -853,7 +853,7 @@ XGL_RESULT intel_desc_layout_create(struct intel_dev *dev,
 
 void intel_desc_layout_destroy(struct intel_desc_layout *layout)
 {
-    icd_free(layout->ranges);
+    intel_free(layout, layout->ranges);
     intel_base_destroy(&layout->obj.base);
 }
 

diff --git a/icd/intel/dev.c b/icd/intel/dev.c
index d9c87a8..063940e 100644 (file)
--- a/icd/intel/dev.c
+++ b/icd/intel/dev.c
@@ -174,7 +174,7 @@ static void dev_clear_msg_filters(struct intel_dev *dev)
     filter = dbg->filters;
     while (filter) {
         struct intel_dev_dbg_msg_filter *next = filter->next;
-        icd_free(filter);
+        intel_free(dev, filter);
         filter = next;
     }
 
@@ -229,7 +229,7 @@ XGL_RESULT intel_dev_add_msg_filter(struct intel_dev *dev,
             f->triggered = false;
         }
     } else {
-        f = icd_alloc(sizeof(*f), 0, XGL_SYSTEM_ALLOC_DEBUG);
+        f = intel_alloc(dev, sizeof(*f), 0, XGL_SYSTEM_ALLOC_DEBUG);
         if (!f)
             return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -257,7 +257,7 @@ void intel_dev_remove_msg_filter(struct intel_dev *dev,
             else
                 dbg->filters = f->next;
 
-            icd_free(f);
+            intel_free(dev, f);
             break;
         }
 

diff --git a/icd/intel/gpu.c b/icd/intel/gpu.c
index 09ab4d2..2785f03 100644 (file)
--- a/icd/intel/gpu.c
+++ b/icd/intel/gpu.c
@@ -121,8 +121,8 @@ void intel_gpu_destroy(struct intel_gpu *gpu)
         intel_wsi_x11_destroy(gpu->x11);
 #endif
 
-    icd_free(gpu->primary_node);
-    icd_free(gpu);
+    intel_free(gpu, gpu->primary_node);
+    intel_free(gpu, gpu);
 }
 
 static int devid_to_gen(int devid)
@@ -160,7 +160,7 @@ XGL_RESULT intel_gpu_create(const struct intel_instance *instance, int devid,
         return XGL_ERROR_INITIALIZATION_FAILED;
     }
 
-    gpu = icd_alloc(sizeof(*gpu), 0, XGL_SYSTEM_ALLOC_API_OBJECT);
+    gpu = intel_alloc(instance, sizeof(*gpu), 0, XGL_SYSTEM_ALLOC_API_OBJECT);
     if (!gpu)
         return XGL_ERROR_OUT_OF_MEMORY;
 
@@ -173,10 +173,10 @@ XGL_RESULT intel_gpu_create(const struct intel_instance *instance, int devid,
     primary_len = strlen(primary_node);
     render_len = (render_node) ? strlen(render_node) : 0;
 
-    gpu->primary_node = icd_alloc(primary_len + 1 +
+    gpu->primary_node = intel_alloc(gpu, primary_len + 1 +
             ((render_len) ? (render_len + 1) : 0), 0, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!gpu->primary_node) {
-        icd_free(gpu);
+        intel_free(instance, gpu);
         return XGL_ERROR_OUT_OF_MEMORY;
     }
 

diff --git a/icd/intel/img.c b/icd/intel/img.c
index 48378f3..55f268e 100644 (file)
--- a/icd/intel/img.c
+++ b/icd/intel/img.c
@@ -146,7 +146,7 @@ XGL_RESULT intel_img_create(struct intel_dev *dev,
     if (layout->separate_stencil) {
         XGL_IMAGE_CREATE_INFO s8_info;
 
-        img->s8_layout = icd_alloc(sizeof(*img->s8_layout), 0,
+        img->s8_layout = intel_alloc(img, sizeof(*img->s8_layout), 0,
                 XGL_SYSTEM_ALLOC_INTERNAL);
         if (!img->s8_layout) {
             intel_img_destroy(img);
@@ -186,7 +186,7 @@ void intel_img_destroy(struct intel_img *img)
 #endif
 
     if (img->s8_layout)
-        icd_free(img->s8_layout);
+        intel_free(img, img->s8_layout);
 
     intel_base_destroy(&img->obj.base);
 }

diff --git a/icd/intel/obj.c b/icd/intel/obj.c
index a8fcd0a..e54f9db 100644 (file)
--- a/icd/intel/obj.c
+++ b/icd/intel/obj.c
@@ -313,7 +313,7 @@ struct intel_base_dbg *intel_base_dbg_create(const struct intel_handle *handle,
 
     assert(dbg_size >= sizeof(*dbg));
 
-    dbg = icd_alloc(dbg_size, 0, XGL_SYSTEM_ALLOC_DEBUG);
+    dbg = intel_alloc(handle, dbg_size, 0, XGL_SYSTEM_ALLOC_DEBUG);
     if (!dbg)
         return NULL;
 
@@ -323,7 +323,7 @@ struct intel_base_dbg *intel_base_dbg_create(const struct intel_handle *handle,
     dbg->type = type;
 
     if (!base_dbg_copy_create_info(dbg, create_info)) {
-        icd_free(dbg);
+        intel_free(handle, dbg);
         return NULL;
     }
 
@@ -358,7 +358,7 @@ struct intel_base *intel_base_create(const struct intel_handle *handle,
 
     assert(obj_size >= sizeof(*base));
 
-    base = icd_alloc(obj_size, 0, XGL_SYSTEM_ALLOC_API_OBJECT);
+    base = intel_alloc(handle, obj_size, 0, XGL_SYSTEM_ALLOC_API_OBJECT);
     if (!base)
         return NULL;
 
@@ -369,7 +369,7 @@ struct intel_base *intel_base_create(const struct intel_handle *handle,
         base->dbg = intel_base_dbg_create(handle,
                 type, create_info, dbg_size);
         if (!base->dbg) {
-            icd_free(base);
+            intel_free(handle, base);
             return NULL;
         }
     }
@@ -383,7 +383,7 @@ void intel_base_destroy(struct intel_base *base)
 {
     if (base->dbg)
         intel_base_dbg_destroy(base->dbg);
-    icd_free(base);
+    intel_free(base, base);
 }
 
 ICD_EXPORT XGL_RESULT XGLAPI xglDestroyObject(
@@ -454,14 +454,14 @@ ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetObjectTag(
     if (!dbg)
         return XGL_SUCCESS;
 
-    tag = icd_alloc(tagSize, 0, XGL_SYSTEM_ALLOC_DEBUG);
+    tag = intel_alloc(base, tagSize, 0, XGL_SYSTEM_ALLOC_DEBUG);
     if (!tag)
         return XGL_ERROR_OUT_OF_MEMORY;
 
     memcpy(tag, pTag, tagSize);
 
     if (dbg->tag)
-        icd_free(dbg->tag);
+        intel_free(base, dbg->tag);
 
     dbg->tag = tag;
     dbg->tag_size = tagSize;

diff --git a/icd/intel/pipeline.c b/icd/intel/pipeline.c
index 216f16d..d5f4be1 100644 (file)
--- a/icd/intel/pipeline.c
+++ b/icd/intel/pipeline.c
@@ -133,14 +133,14 @@ struct intel_pipeline_shader *intel_pipeline_shader_create_meta(struct intel_dev
     struct intel_pipeline_shader *sh;
     XGL_RESULT ret;
 
-    sh = icd_alloc(sizeof(*sh), 0, XGL_SYSTEM_ALLOC_INTERNAL);
+    sh = intel_alloc(dev, sizeof(*sh), 0, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!sh)
         return NULL;
     memset(sh, 0, sizeof(*sh));
 
     ret = intel_pipeline_shader_compile_meta(sh, dev->gpu, id);
     if (ret != XGL_SUCCESS) {
-        icd_free(sh);
+        intel_free(dev, sh);
         return NULL;
     }
 

diff --git a/icd/intel/state.c b/icd/intel/state.c
index 3186f64..17c3526 100644 (file)
--- a/icd/intel/state.c
+++ b/icd/intel/state.c
@@ -117,7 +117,7 @@ viewport_state_alloc_cmd(struct intel_dynamic_vp *state,
     state->cmd_scissor_rect_pos = state->cmd_len;
     state->cmd_len += 2 * info->viewportAndScissorCount;
 
-    state->cmd = icd_alloc(sizeof(uint32_t) * state->cmd_len,
+    state->cmd = intel_alloc(state, sizeof(uint32_t) * state->cmd_len,
             0, XGL_SYSTEM_ALLOC_INTERNAL);
     if (!state->cmd)
         return XGL_ERROR_OUT_OF_MEMORY;
@@ -249,7 +249,7 @@ XGL_RESULT intel_viewport_state_create(struct intel_dev *dev,
 
 void intel_viewport_state_destroy(struct intel_dynamic_vp *state)
 {
-    icd_free(state->cmd);
+    intel_free(state, state->cmd);
     intel_base_destroy(&state->obj.base);
 }