Adding some useful trace zones for task system overheads.

iree/base/internal/arena.c

diff --git a/iree/base/internal/arena.c b/iree/base/internal/arena.c
index 791b24a..6065daa 100644
--- a/iree/base/internal/arena.c
+++ b/iree/base/internal/arena.c
@@ -18,22 +18,32 @@
 void iree_arena_block_pool_initialize(iree_host_size_t total_block_size,
                                       iree_allocator_t block_allocator,
                                       iree_arena_block_pool_t* out_block_pool) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   memset(out_block_pool, 0, sizeof(*out_block_pool));
   out_block_pool->total_block_size = total_block_size;
   out_block_pool->usable_block_size =
       total_block_size - sizeof(iree_arena_block_t);
   out_block_pool->block_allocator = block_allocator;
   iree_atomic_arena_block_slist_initialize(&out_block_pool->available_slist);
+
+  IREE_TRACE_ZONE_END(z0);
 }
 
 void iree_arena_block_pool_deinitialize(iree_arena_block_pool_t* block_pool) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   // Since all blocks must have been released we can just reuse trim (today) as
   // it doesn't retain any blocks.
   iree_arena_block_pool_trim(block_pool);
   iree_atomic_arena_block_slist_deinitialize(&block_pool->available_slist);
+
+  IREE_TRACE_ZONE_END(z0);
 }
 
 void iree_arena_block_pool_trim(iree_arena_block_pool_t* block_pool) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   iree_arena_block_t* head = NULL;
   iree_atomic_arena_block_slist_flush(
       &block_pool->available_slist,
@@ -43,6 +53,8 @@
     head = head->next;
     iree_allocator_free(block_pool->block_allocator, ptr);
   }
+
+  IREE_TRACE_ZONE_END(z0);
 }
 
 iree_status_t iree_arena_block_pool_acquire(iree_arena_block_pool_t* block_pool,
@@ -99,6 +111,8 @@
 }
 
 void iree_arena_reset(iree_arena_allocator_t* arena) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   if (arena->allocation_head != NULL) {
     iree_arena_oversized_allocation_t* head = arena->allocation_head;
     do {
@@ -114,6 +128,8 @@
     arena->block_head = NULL;
     arena->block_tail = NULL;
   }
+
+  IREE_TRACE_ZONE_END(z0);
 }
 
 iree_status_t iree_arena_allocate(iree_arena_allocator_t* arena,
@@ -127,16 +143,20 @@
     // Oversized allocation that can't be handled by the block pool. We'll
     // allocate directly from the system allocator and track it ourselves for
     // freeing during reset.
+    IREE_TRACE_ZONE_BEGIN(z0);
     iree_host_size_t allocation_size =
         sizeof(iree_arena_oversized_allocation_t) + byte_length;
     iree_arena_oversized_allocation_t* allocation = NULL;
-    IREE_RETURN_IF_ERROR(iree_allocator_malloc_uninitialized(
-        block_pool->block_allocator, allocation_size, (void**)&allocation));
+    IREE_RETURN_AND_END_ZONE_IF_ERROR(
+        z0,
+        iree_allocator_malloc_uninitialized(
+            block_pool->block_allocator, allocation_size, (void**)&allocation));
     allocation->next = arena->allocation_head;
     arena->allocation_head = allocation;
     arena->total_allocation_size += allocation_size;
     arena->used_allocation_size += byte_length;
     *out_ptr = (uint8_t*)allocation + sizeof(iree_arena_oversized_allocation_t);
+    IREE_TRACE_ZONE_END(z0);
     return iree_ok_status();
   }
 
@@ -148,14 +168,16 @@
   // Check to see if the current block (if any) has space - if not, get another.
   if (arena->block_head == NULL ||
       arena->block_bytes_remaining < aligned_length) {
+    IREE_TRACE_ZONE_BEGIN(z0);
     iree_arena_block_t* block = NULL;
-    IREE_RETURN_IF_ERROR(
-        iree_arena_block_pool_acquire(arena->block_pool, &block));
+    IREE_RETURN_AND_END_ZONE_IF_ERROR(
+        z0, iree_arena_block_pool_acquire(arena->block_pool, &block));
     block->next = arena->block_head;
     arena->block_head = block;
     if (!arena->block_tail) arena->block_tail = block;
     arena->total_allocation_size += block_pool->total_block_size;
     arena->block_bytes_remaining = block_pool->usable_block_size;
+    IREE_TRACE_ZONE_END(z0);
   }
 
   // Slice out the allocation from the current block.

iree/modules/hal/module.c

diff --git a/iree/modules/hal/module.c b/iree/modules/hal/module.c
index 0a6f449..2a63d22 100644
--- a/iree/modules/hal/module.c
+++ b/iree/modules/hal/module.c
@@ -143,39 +143,50 @@
 static iree_status_t IREE_API_PTR
 iree_hal_module_alloc_state(void* self, iree_allocator_t host_allocator,
                             iree_vm_module_state_t** out_module_state) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   iree_hal_module_t* module = IREE_HAL_MODULE_CAST(self);
   iree_hal_module_state_t* state = NULL;
-  IREE_RETURN_IF_ERROR(
+  IREE_RETURN_AND_END_ZONE_IF_ERROR(
+      z0,
       iree_allocator_malloc(host_allocator, sizeof(*state), (void**)&state));
   memset(state, 0, sizeof(*state));
   state->host_allocator = host_allocator;
   state->shared_device = module->shared_device;
   iree_hal_device_retain(state->shared_device);
 
-  IREE_RETURN_IF_ERROR(iree_vm_list_create(
-      /*element_type=*/NULL, /*initial_capacity=*/512, state->host_allocator,
-      &state->deferred_releases));
+  IREE_RETURN_AND_END_ZONE_IF_ERROR(
+      z0, iree_vm_list_create(
+              /*element_type=*/NULL, /*initial_capacity=*/32,
+              state->host_allocator, &state->deferred_releases));
 
-  IREE_RETURN_IF_ERROR(iree_hal_executable_cache_create(
-      state->shared_device, iree_string_view_empty(),
-      &state->executable_cache));
+  IREE_RETURN_AND_END_ZONE_IF_ERROR(
+      z0, iree_hal_executable_cache_create(state->shared_device,
+                                           iree_string_view_empty(),
+                                           &state->executable_cache));
 
   state->submit_value = 0ull;
-  IREE_RETURN_IF_ERROR(iree_hal_semaphore_create(
-      state->shared_device, state->submit_value, &state->submit_semaphore));
+  IREE_RETURN_AND_END_ZONE_IF_ERROR(
+      z0, iree_hal_semaphore_create(state->shared_device, state->submit_value,
+                                    &state->submit_semaphore));
 
   *out_module_state = (iree_vm_module_state_t*)state;
+  IREE_TRACE_ZONE_END(z0);
   return iree_ok_status();
 }
 
 static void IREE_API_PTR
 iree_hal_module_free_state(void* self, iree_vm_module_state_t* module_state) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   iree_hal_module_state_t* state = (iree_hal_module_state_t*)module_state;
   iree_hal_semaphore_release(state->submit_semaphore);
   iree_vm_list_release(state->deferred_releases);
   iree_hal_executable_cache_release(state->executable_cache);
   iree_hal_device_release(state->shared_device);
   iree_allocator_free(state->host_allocator, state);
+
+  IREE_TRACE_ZONE_END(z0);
 }
 
 static iree_status_t IREE_API_PTR iree_hal_module_notify(

iree/vm/list.c

diff --git a/iree/vm/list.c b/iree/vm/list.c
index a373d74..f1046cc 100644
--- a/iree/vm/list.c
+++ b/iree/vm/list.c
@@ -11,6 +11,8 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "iree/base/tracing.h"
+
 // Size of each iree_vm_value_type_t in bytes.
 static const iree_host_size_t kValueTypeSizes[7] = {
     0,  // IREE_VM_VALUE_TYPE_NONE
@@ -114,6 +116,8 @@
 IREE_API_EXPORT iree_status_t iree_vm_list_initialize(
     iree_byte_span_t storage, const iree_vm_type_def_t* element_type,
     iree_host_size_t capacity, iree_vm_list_t** out_list) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   iree_vm_list_storage_mode_t storage_mode = IREE_VM_LIST_STORAGE_MODE_VARIANT;
   iree_host_size_t element_size = sizeof(iree_vm_variant_t);
   if (element_type) {
@@ -151,22 +155,30 @@
   list->storage = storage.data + storage_offset;
 
   *out_list = list;
+  IREE_TRACE_ZONE_END(z0);
   return iree_ok_status();
 }
 
 IREE_API_EXPORT void iree_vm_list_deinitialize(iree_vm_list_t* list) {
   IREE_ASSERT_ARGUMENT(list);
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   iree_atomic_ref_count_abort_if_uses(&list->ref_object.counter);
   iree_vm_list_reset_range(list, 0, list->count);
   list->count = 0;
+
+  IREE_TRACE_ZONE_END(z0);
 }
 
 IREE_API_EXPORT iree_status_t iree_vm_list_create(
     const iree_vm_type_def_t* element_type, iree_host_size_t initial_capacity,
     iree_allocator_t allocator, iree_vm_list_t** out_list) {
+  IREE_ASSERT_ARGUMENT(out_list);
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   iree_vm_list_t* list = NULL;
-  IREE_RETURN_IF_ERROR(
-      iree_allocator_malloc(allocator, sizeof(*list), (void**)&list));
+  IREE_RETURN_AND_END_ZONE_IF_ERROR(
+      z0, iree_allocator_malloc(allocator, sizeof(*list), (void**)&list));
   memset(list, 0, sizeof(*list));
   iree_atomic_ref_count_init(&list->ref_object.counter);
   list->allocator = allocator;
@@ -186,20 +198,25 @@
   }
 
   iree_status_t status = iree_vm_list_reserve(list, initial_capacity);
-  if (!iree_status_is_ok(status)) {
-    iree_allocator_free(allocator, list);
-    return status;
-  }
 
-  *out_list = list;
-  return iree_ok_status();
+  if (iree_status_is_ok(status)) {
+    *out_list = list;
+  } else {
+    iree_allocator_free(allocator, list);
+  }
+  IREE_TRACE_ZONE_END(z0);
+  return status;
 }
 
 static void iree_vm_list_destroy(void* ptr) {
+  IREE_TRACE_ZONE_BEGIN(z0);
+
   iree_vm_list_t* list = (iree_vm_list_t*)ptr;
   iree_vm_list_reset_range(list, 0, list->count);
   iree_allocator_free(list->allocator, list->storage);
   iree_allocator_free(list->allocator, list);
+
+  IREE_TRACE_ZONE_END(z0);
 }
 
 IREE_API_EXPORT void iree_vm_list_retain(iree_vm_list_t* list) {