kernel/mem_slab.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2016 Wind River Systems, Inc.
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/kernel.h>

 #include <zephyr/toolchain.h>
 #include <zephyr/linker/sections.h>
 #include <zephyr/sys/dlist.h>
 #include <zephyr/init.h>
 #include <zephyr/sys/check.h>
 #include <zephyr/sys/iterable_sections.h>
 #include <zephyr/sys/minmax.h>
 #include <string.h>
 /* private kernel APIs */
 #include <ksched.h>
 #include <kernel_internal.h>
 #include <scheduler.h>
 #include <wait_q.h>

 #ifdef CONFIG_OBJ_CORE_MEM_SLAB
 static struct k_obj_type obj_type_mem_slab;

 #ifdef CONFIG_OBJ_CORE_STATS_MEM_SLAB

 static int k_mem_slab_stats_raw(struct k_obj_core *obj_core, void *stats)
 {
 	__ASSERT((obj_core != NULL) && (stats != NULL), "NULL parameter");

 	struct k_mem_slab *slab;
 	k_spinlock_key_t   key;

 	slab = CONTAINER_OF(obj_core, struct k_mem_slab, obj_core);
 	key = k_spin_lock(&slab->lock);
 	memcpy(stats, &slab->info, sizeof(slab->info));
 	k_spin_unlock(&slab->lock, key);

 	return 0;
 }

 static int k_mem_slab_stats_query(struct k_obj_core *obj_core, void *stats)
 {
 	__ASSERT((obj_core != NULL) && (stats != NULL), "NULL parameter");

 	struct k_mem_slab *slab;
 	k_spinlock_key_t   key;
 	struct sys_memory_stats *ptr = stats;

 	slab = CONTAINER_OF(obj_core, struct k_mem_slab, obj_core);
 	key = k_spin_lock(&slab->lock);
 	ptr->free_bytes = (slab->info.num_blocks - slab->info.num_used) *
 			  slab->info.block_size;
 	ptr->allocated_bytes = slab->info.num_used * slab->info.block_size;
 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 	ptr->max_allocated_bytes = slab->info.max_used * slab->info.block_size;
 #else
 	ptr->max_allocated_bytes = 0;
 #endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
 	k_spin_unlock(&slab->lock, key);

 	return 0;
 }

 static int k_mem_slab_stats_reset(struct k_obj_core *obj_core)
 {
 	__ASSERT(obj_core != NULL, "NULL parameter");

 	struct k_mem_slab *slab;
 	k_spinlock_key_t   key;

 	slab = CONTAINER_OF(obj_core, struct k_mem_slab, obj_core);
 	key = k_spin_lock(&slab->lock);

 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 	slab->info.max_used = slab->info.num_used;
 #endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

 	k_spin_unlock(&slab->lock, key);

 	return 0;
 }

 static struct k_obj_core_stats_desc mem_slab_stats_desc = {
 	.raw_size = sizeof(struct k_mem_slab_info),
 	.query_size = sizeof(struct sys_memory_stats),
 	.raw   = k_mem_slab_stats_raw,
 	.query = k_mem_slab_stats_query,
 	.reset = k_mem_slab_stats_reset,
 	.disable = NULL,
 	.enable = NULL,
 };

 K_OBJ_TYPE_DEFINE_STATS(obj_type_mem_slab, k_mem_slab, K_OBJ_TYPE_MEM_SLAB_ID,
 			&mem_slab_stats_desc, info);
 #else
 K_OBJ_TYPE_DEFINE(obj_type_mem_slab, k_mem_slab, K_OBJ_TYPE_MEM_SLAB_ID, NULL);
 #endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */
 #endif /* CONFIG_OBJ_CORE_MEM_SLAB */

 /**
  * @brief Initialize kernel memory slab subsystem.
  *
  * Perform any initialization of memory slabs that wasn't done at build time.
  * Currently this just involves creating the list of free blocks for each slab.
  *
  * @retval 0 on success.
  * @retval -EINVAL if @p slab contains invalid configuration and/or values.
  */
 static int create_free_list(struct k_mem_slab *slab)
 {
 	char *p;
 	size_t total_size;

 	CHECKIF(slab->info.block_size == 0U) {
 		return -EINVAL;
 	}

 	/* blocks must be word aligned */
 	CHECKIF(((slab->info.block_size | (uintptr_t)slab->buffer) &
 				(sizeof(void *) - 1)) != 0U) {
 		return -EINVAL;
 	}

 	if (size_mul_overflow(slab->info.block_size, slab->info.num_blocks, &total_size)) {
 		return -EINVAL;
 	}
 	if (size_add_overflow((size_t)(uintptr_t)slab->buffer, total_size, &total_size)) {
 		return -EINVAL;
 	}

 	slab->free_list = NULL;
 	p = (char *)(total_size - slab->info.block_size);

 	for (uint32_t i = 0; i < slab->info.num_blocks; i++) {
 		*(char **)p = slab->free_list;
 		slab->free_list = p;
 		p -= slab->info.block_size;
 	}

 	return 0;
 }

 /**
  * @brief Complete initialization of statically defined memory slabs.
  *
  * Build the free block list for each statically defined slab. This is
  * mandatory functional initialization, required whether or not the object
  * core framework is enabled, so it stays as its own init rather than moving
  * into the object core registration (see K_OBJ_TYPE_DEFINE_STATS above, which
  * handles this slab type's object core duties).
  *
  * Initialization stops at the first slab with an invalid configuration
  * (create_free_list() fails), matching the previous SYS_INIT behavior whose
  * return value was discarded by the init runner.
  */
 static void init_mem_slab_module(void)
 {
 	STRUCT_SECTION_FOREACH(k_mem_slab, slab) {
 		if (create_free_list(slab) < 0) {
 			return;
 		}
 		k_object_init(slab);
 	}
 }

 K_KERNEL_INIT_PRE(init_mem_slab_module);

 int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
 		    size_t block_size, uint32_t num_blocks)
 {
 	int rc;

 	slab->info.num_blocks = num_blocks;
 	slab->info.block_size = block_size;
 	slab->buffer = buffer;
 	slab->info.num_used = 0U;
 	slab->lock = (struct k_spinlock) {};

 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 	slab->info.max_used = 0U;
 #endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

 	rc = create_free_list(slab);
 	if (rc < 0) {
 		goto out;
 	}

 #ifdef CONFIG_OBJ_CORE_MEM_SLAB
 	k_obj_core_init_and_link(K_OBJ_CORE(slab), &obj_type_mem_slab);
 #endif /* CONFIG_OBJ_CORE_MEM_SLAB */
 #ifdef CONFIG_OBJ_CORE_STATS_MEM_SLAB
 	k_obj_core_stats_register(K_OBJ_CORE(slab), &slab->info,
 				  sizeof(struct k_mem_slab_info));
 #endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */

 	z_waitq_init(&slab->wait_q);
 	k_object_init(slab);
 out:
 	SYS_PORT_TRACING_OBJ_INIT(k_mem_slab, slab, rc);

 	return rc;
 }

 static bool slab_ptr_is_good(struct k_mem_slab *slab, const void *ptr)
 {
 	if (!IS_ENABLED(CONFIG_MEM_SLAB_POINTER_VALIDATE)) {
 		return true;
 	}

 	const char *p = ptr;
 	ptrdiff_t offset = p - slab->buffer;

 	return (offset >= 0) &&
 	       (offset < (slab->info.block_size * slab->info.num_blocks)) &&
 	       ((offset % slab->info.block_size) == 0);
 }

 int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem, k_timeout_t timeout)
 {
 	k_spinlock_key_t key = k_spin_lock(&slab->lock);
 	int result;

 	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_mem_slab, alloc, slab, timeout);

 	if (slab->free_list != NULL) {
 		/* take a free block */
 		*mem = slab->free_list;
 		slab->free_list = *(char **)(slab->free_list);
 		slab->info.num_used++;
 		__ASSERT((slab->free_list == NULL &&
 			  slab->info.num_used == slab->info.num_blocks) ||
 			 slab_ptr_is_good(slab, slab->free_list),
 			 "slab corruption detected");

 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 		slab->info.max_used = max(slab->info.num_used,
 					  slab->info.max_used);
 #endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

 		result = 0;
 	} else if (K_TIMEOUT_EQ(timeout, K_NO_WAIT) ||
 		   !IS_ENABLED(CONFIG_MULTITHREADING)) {
 		/* don't wait for a free block to become available */
 		*mem = NULL;
 		result = -ENOMEM;
 	} else {
 		SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_mem_slab, alloc, slab, timeout);

 		/* wait for a free block or timeout */
 		result = z_pend_curr(&slab->lock, key, &slab->wait_q, timeout);
 		if (result == 0) {
 			*mem = _current->base.swap_data;
 		}

 		SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, alloc, slab, timeout, result);

 		return result;
 	}

 	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, alloc, slab, timeout, result);

 	k_spin_unlock(&slab->lock, key);

 	return result;
 }

 void k_mem_slab_free(struct k_mem_slab *slab, void *mem)
 {
 	if (!slab_ptr_is_good(slab, mem)) {
 		__ASSERT(false, "Invalid memory pointer provided");
 		k_panic();
 		return;
 	}

 	k_spinlock_key_t key = k_spin_lock(&slab->lock);

 	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_mem_slab, free, slab);
 	if (unlikely(slab->free_list == NULL) && IS_ENABLED(CONFIG_MULTITHREADING)) {
 		if (z_sched_wake(&slab->wait_q, 0, mem)) {
 			SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, free, slab);
 			z_reschedule(&slab->lock, key);
 			return;
 		}
 	}
 	*(char **) mem = slab->free_list;
 	slab->free_list = (char *) mem;
 	slab->info.num_used--;

 	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, free, slab);

 	k_spin_unlock(&slab->lock, key);
 }

 int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats)
 {
 	if ((slab == NULL) || (stats == NULL)) {
 		return -EINVAL;
 	}

 	k_spinlock_key_t key = k_spin_lock(&slab->lock);

 	stats->allocated_bytes = slab->info.num_used * slab->info.block_size;
 	stats->free_bytes = (slab->info.num_blocks - slab->info.num_used) *
 			    slab->info.block_size;
 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 	stats->max_allocated_bytes = slab->info.max_used *
 				     slab->info.block_size;
 #else
 	stats->max_allocated_bytes = 0;
 #endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

 	k_spin_unlock(&slab->lock, key);

 	return 0;
 }

 #ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
 int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab)
 {
 	if (slab == NULL) {
 		return -EINVAL;
 	}

 	k_spinlock_key_t key = k_spin_lock(&slab->lock);

 	slab->info.max_used = slab->info.num_used;

 	k_spin_unlock(&slab->lock, key);

 	return 0;
 }
 #endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
	/*
	* Copyright (c) 2016 Wind River Systems, Inc.
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/kernel.h>

	#include <zephyr/toolchain.h>
	#include <zephyr/linker/sections.h>
	#include <zephyr/sys/dlist.h>
	#include <zephyr/init.h>
	#include <zephyr/sys/check.h>
	#include <zephyr/sys/iterable_sections.h>
	#include <zephyr/sys/minmax.h>
	#include <string.h>
	/* private kernel APIs */
	#include <ksched.h>
	#include <kernel_internal.h>
	#include <scheduler.h>
	#include <wait_q.h>

	#ifdef CONFIG_OBJ_CORE_MEM_SLAB
	static struct k_obj_type obj_type_mem_slab;

	#ifdef CONFIG_OBJ_CORE_STATS_MEM_SLAB

	static int k_mem_slab_stats_raw(struct k_obj_core obj_core, void stats)
	{
	__ASSERT((obj_core != NULL) && (stats != NULL), "NULL parameter");

	struct k_mem_slab *slab;
	k_spinlock_key_t key;

	slab = CONTAINER_OF(obj_core, struct k_mem_slab, obj_core);
	key = k_spin_lock(&slab->lock);
	memcpy(stats, &slab->info, sizeof(slab->info));
	k_spin_unlock(&slab->lock, key);

	return 0;
	}

	static int k_mem_slab_stats_query(struct k_obj_core obj_core, void stats)
	{
	__ASSERT((obj_core != NULL) && (stats != NULL), "NULL parameter");

	struct k_mem_slab *slab;
	k_spinlock_key_t key;
	struct sys_memory_stats *ptr = stats;

	slab = CONTAINER_OF(obj_core, struct k_mem_slab, obj_core);
	key = k_spin_lock(&slab->lock);
	ptr->free_bytes = (slab->info.num_blocks - slab->info.num_used) *
	slab->info.block_size;
	ptr->allocated_bytes = slab->info.num_used * slab->info.block_size;
	#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
	ptr->max_allocated_bytes = slab->info.max_used * slab->info.block_size;
	#else
	ptr->max_allocated_bytes = 0;
	#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */
	k_spin_unlock(&slab->lock, key);

	return 0;
	}

	static int k_mem_slab_stats_reset(struct k_obj_core *obj_core)
	{
	__ASSERT(obj_core != NULL, "NULL parameter");

	struct k_mem_slab *slab;
	k_spinlock_key_t key;

	slab = CONTAINER_OF(obj_core, struct k_mem_slab, obj_core);
	key = k_spin_lock(&slab->lock);

	#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
	slab->info.max_used = slab->info.num_used;
	#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

	k_spin_unlock(&slab->lock, key);

	return 0;
	}

	static struct k_obj_core_stats_desc mem_slab_stats_desc = {
	.raw_size = sizeof(struct k_mem_slab_info),
	.query_size = sizeof(struct sys_memory_stats),
	.raw = k_mem_slab_stats_raw,
	.query = k_mem_slab_stats_query,
	.reset = k_mem_slab_stats_reset,
	.disable = NULL,
	.enable = NULL,
	};

	K_OBJ_TYPE_DEFINE_STATS(obj_type_mem_slab, k_mem_slab, K_OBJ_TYPE_MEM_SLAB_ID,
	&mem_slab_stats_desc, info);
	#else
	K_OBJ_TYPE_DEFINE(obj_type_mem_slab, k_mem_slab, K_OBJ_TYPE_MEM_SLAB_ID, NULL);
	#endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */
	#endif /* CONFIG_OBJ_CORE_MEM_SLAB */

	/**
	* @brief Initialize kernel memory slab subsystem.
	*
	* Perform any initialization of memory slabs that wasn't done at build time.
	* Currently this just involves creating the list of free blocks for each slab.
	*
	* @retval 0 on success.
	* @retval -EINVAL if @p slab contains invalid configuration and/or values.
	*/
	static int create_free_list(struct k_mem_slab *slab)
	{
	char *p;
	size_t total_size;

	CHECKIF(slab->info.block_size == 0U) {
	return -EINVAL;
	}

	/* blocks must be word aligned */
	CHECKIF(((slab->info.block_size \| (uintptr_t)slab->buffer) &
	(sizeof(void *) - 1)) != 0U) {
	return -EINVAL;
	}

	if (size_mul_overflow(slab->info.block_size, slab->info.num_blocks, &total_size)) {
	return -EINVAL;
	}
	if (size_add_overflow((size_t)(uintptr_t)slab->buffer, total_size, &total_size)) {
	return -EINVAL;
	}

	slab->free_list = NULL;
	p = (char *)(total_size - slab->info.block_size);

	for (uint32_t i = 0; i < slab->info.num_blocks; i++) {
	(char *)p = slab->free_list;
	slab->free_list = p;
	p -= slab->info.block_size;
	}

	return 0;
	}

	/**
	* @brief Complete initialization of statically defined memory slabs.
	*
	* Build the free block list for each statically defined slab. This is
	* mandatory functional initialization, required whether or not the object
	* core framework is enabled, so it stays as its own init rather than moving
	* into the object core registration (see K_OBJ_TYPE_DEFINE_STATS above, which
	* handles this slab type's object core duties).
	*
	* Initialization stops at the first slab with an invalid configuration
	* (create_free_list() fails), matching the previous SYS_INIT behavior whose
	* return value was discarded by the init runner.
	*/
	static void init_mem_slab_module(void)
	{
	STRUCT_SECTION_FOREACH(k_mem_slab, slab) {
	if (create_free_list(slab) < 0) {
	return;
	}
	k_object_init(slab);
	}
	}

	K_KERNEL_INIT_PRE(init_mem_slab_module);

	int k_mem_slab_init(struct k_mem_slab slab, void buffer,
	size_t block_size, uint32_t num_blocks)
	{
	int rc;

	slab->info.num_blocks = num_blocks;
	slab->info.block_size = block_size;
	slab->buffer = buffer;
	slab->info.num_used = 0U;
	slab->lock = (struct k_spinlock) {};

	#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
	slab->info.max_used = 0U;
	#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

	rc = create_free_list(slab);
	if (rc < 0) {
	goto out;
	}

	#ifdef CONFIG_OBJ_CORE_MEM_SLAB
	k_obj_core_init_and_link(K_OBJ_CORE(slab), &obj_type_mem_slab);
	#endif /* CONFIG_OBJ_CORE_MEM_SLAB */
	#ifdef CONFIG_OBJ_CORE_STATS_MEM_SLAB
	k_obj_core_stats_register(K_OBJ_CORE(slab), &slab->info,
	sizeof(struct k_mem_slab_info));
	#endif /* CONFIG_OBJ_CORE_STATS_MEM_SLAB */

	z_waitq_init(&slab->wait_q);
	k_object_init(slab);
	out:
	SYS_PORT_TRACING_OBJ_INIT(k_mem_slab, slab, rc);

	return rc;
	}

	static bool slab_ptr_is_good(struct k_mem_slab slab, const void ptr)
	{
	if (!IS_ENABLED(CONFIG_MEM_SLAB_POINTER_VALIDATE)) {
	return true;
	}

	const char *p = ptr;
	ptrdiff_t offset = p - slab->buffer;

	return (offset >= 0) &&
	(offset < (slab->info.block_size * slab->info.num_blocks)) &&
	((offset % slab->info.block_size) == 0);
	}

	int k_mem_slab_alloc(struct k_mem_slab slab, void *mem, k_timeout_t timeout)
	{
	k_spinlock_key_t key = k_spin_lock(&slab->lock);
	int result;

	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_mem_slab, alloc, slab, timeout);

	if (slab->free_list != NULL) {
	/* take a free block */
	*mem = slab->free_list;
	slab->free_list = (char *)(slab->free_list);
	slab->info.num_used++;
	__ASSERT((slab->free_list == NULL &&
	slab->info.num_used == slab->info.num_blocks) \|\|
	slab_ptr_is_good(slab, slab->free_list),
	"slab corruption detected");

	#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
	slab->info.max_used = max(slab->info.num_used,
	slab->info.max_used);
	#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

	result = 0;
	} else if (K_TIMEOUT_EQ(timeout, K_NO_WAIT) \|\|
	!IS_ENABLED(CONFIG_MULTITHREADING)) {
	/* don't wait for a free block to become available */
	*mem = NULL;
	result = -ENOMEM;
	} else {
	SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_mem_slab, alloc, slab, timeout);

	/* wait for a free block or timeout */
	result = z_pend_curr(&slab->lock, key, &slab->wait_q, timeout);
	if (result == 0) {
	*mem = _current->base.swap_data;
	}

	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, alloc, slab, timeout, result);

	return result;
	}

	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, alloc, slab, timeout, result);

	k_spin_unlock(&slab->lock, key);

	return result;
	}

	void k_mem_slab_free(struct k_mem_slab slab, void mem)
	{
	if (!slab_ptr_is_good(slab, mem)) {
	__ASSERT(false, "Invalid memory pointer provided");
	k_panic();
	return;
	}

	k_spinlock_key_t key = k_spin_lock(&slab->lock);

	SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_mem_slab, free, slab);
	if (unlikely(slab->free_list == NULL) && IS_ENABLED(CONFIG_MULTITHREADING)) {
	if (z_sched_wake(&slab->wait_q, 0, mem)) {
	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, free, slab);
	z_reschedule(&slab->lock, key);
	return;
	}
	}
	(char *) mem = slab->free_list;
	slab->free_list = (char *) mem;
	slab->info.num_used--;

	SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_mem_slab, free, slab);

	k_spin_unlock(&slab->lock, key);
	}

	int k_mem_slab_runtime_stats_get(struct k_mem_slab slab, struct sys_memory_stats stats)
	{
	if ((slab == NULL) \|\| (stats == NULL)) {
	return -EINVAL;
	}

	k_spinlock_key_t key = k_spin_lock(&slab->lock);

	stats->allocated_bytes = slab->info.num_used * slab->info.block_size;
	stats->free_bytes = (slab->info.num_blocks - slab->info.num_used) *
	slab->info.block_size;
	#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
	stats->max_allocated_bytes = slab->info.max_used *
	slab->info.block_size;
	#else
	stats->max_allocated_bytes = 0;
	#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */

	k_spin_unlock(&slab->lock, key);

	return 0;
	}

	#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
	int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab)
	{
	if (slab == NULL) {
	return -EINVAL;
	}

	k_spinlock_key_t key = k_spin_lock(&slab->lock);

	slab->info.max_used = slab->info.num_used;

	k_spin_unlock(&slab->lock, key);

	return 0;
	}
	#endif /* CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION */