src/memory.c - platform/external/XNNPACK - Git at Google

 // Copyright 2021 Google LLC
 //
 // This source code is licensed under the BSD-style license found in the
 // LICENSE file in the root directory of this source tree.

 // Include first for the platform detection macros.
 #include "xnnpack/common.h"

 #if XNN_PLATFORM_WINDOWS
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <windows.h>
 #else
 // This define needs to come first because errno include features.h and would have defined macros that lead to
 // sys/mman.h not having mremap.
 #if !defined(_GNU_SOURCE)
 #define _GNU_SOURCE
 #endif
 #include <errno.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #endif

 #include <stddef.h>
 #include <stdint.h>
 #include <xnnpack.h>

 #include "xnnpack/allocator.h"
 #include "xnnpack/log.h"
 #include "xnnpack/math.h"
 #include "xnnpack/params.h"

 // Helpers to allocate/mmap and release memory used by both code and weights cache.

 // Maps `size` bytes of memory, returns pointer to allocation, NULL if failed.
 static void* allocate_buffer(size_t size) {
   xnn_log_debug("allocating buffer of size %zu", size);
   assert(size == round_up_po2(size, xnn_params.page_size));
 #if XNN_PLATFORM_WINDOWS
   void* p = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
   if (p == NULL) {
     xnn_log_error("failed to allocate %zu bytes for code/weights buffer, error code: %" PRIu32,
                   size, (uint32_t) GetLastError());
     return NULL;
   }
 #else
   void* p = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   if (p == MAP_FAILED) {
     xnn_log_error("failed to allocate %zu bytes for code/weights buffer, error code: %d", size, errno);
     return NULL;
   }
 #endif
   return p;
 }

 // Releases memory previously mapped by `allocate_buffer`, returns xnn_status_success on success.
 static enum xnn_status release_memory(void* start, size_t capacity) {
 #if XNN_PLATFORM_WINDOWS
   // We only decommited any unused capacity, so we release all of it now.
   if (!VirtualFree(start, 0, MEM_RELEASE)) {
     xnn_log_error("failed to release code/weights buffer, error code: %" PRIu32, (uint32_t) GetLastError());
     return xnn_status_invalid_state;
   }
 #else
   if (munmap(start, capacity) == -1) {
     xnn_log_error("failed to release code/weights buffer, error code: %d", errno);
     return xnn_status_invalid_state;
   }
 #endif
   return xnn_status_success;
 }

 // Resize a buffer at old_pointer of size old_bytes to new_size. The actual new size of the resized buffer is written to
 // new_capacity_out, which can be >= new_size due to page alignment requirements.
 // Returns a pointer to a buffer which might be the same as old_pointer if we can remap virtual memory, otherwise we
 // allocate a new buffer and copy contents of old_buffer over.
 static void* resize_buffer(
   void* old_pointer, size_t old_size, size_t old_capacity, size_t new_size, size_t* new_capacity_out)
 {
   size_t new_capacity = round_up_po2(new_size, xnn_params.page_size);
 #if XNN_PLATFORM_LINUX
   void* new_pointer = mremap(old_pointer, old_size, new_capacity, MREMAP_MAYMOVE, NULL);
   if (new_pointer == MAP_FAILED) {
     xnn_log_error("mremap failed with errno: %d", errno);
     return NULL;
   }
   xnn_log_debug("resize_buffer: remap, old capacity %zu to new capacity %zu", old_capacity, new_capacity);
 #else
   void* new_pointer = allocate_buffer(new_capacity);
   if (new_pointer == NULL) {
     xnn_log_error("allocate_buffer failed");
     return NULL;
   }
   memcpy(new_pointer, old_pointer, old_size);
   // Release old code_buffer.
   enum xnn_status status = release_memory(old_pointer, old_capacity);
   if (status != xnn_status_success) {
     xnn_log_error("releasing old buffer failed, this could be a leak of %zu bytes", old_capacity);
     // Log but proceed as per normal since we successfully allocated a new memory that can be used by the caller.
   }
   xnn_log_debug("resize_buffer: allocate memory, old capacity %zu to new capacity %zu", old_capacity, new_capacity);
 #endif
   *new_capacity_out = new_capacity;
   return new_pointer;
 }

 enum xnn_status xnn_allocate_code_memory(struct xnn_code_buffer* buf, size_t size) {
   memset(buf, 0, sizeof(struct xnn_code_buffer));
   size_t page_aligned_size = round_up_po2(size, xnn_params.page_size);
   buf->start = allocate_buffer(page_aligned_size);
   if (buf->start == NULL) {
     return xnn_status_out_of_memory;
   }

   buf->size = 0;
   buf->capacity = page_aligned_size;
   return xnn_status_success;
 }

 // Releases unused memory. Will write the new capacity to `capacity`.
 static enum xnn_status release_unused_memory(size_t size, void* start, size_t* capacity) {
   // Release all unused pages.
   const size_t page_aligned_size = round_up_po2(size, xnn_params.page_size);
   const uint8_t* mem_start = (uint8_t*) start;
   const uint8_t* unused_start = mem_start + page_aligned_size;
   assert(*capacity >= page_aligned_size);
   const size_t unused_capacity = *capacity - page_aligned_size;

   xnn_log_debug("releasing memory, start %p, used: %zu, capacity: %zu, unused %zu", mem_start, size, *capacity,
                 unused_capacity);

   if (unused_capacity != 0) {
     // Free unused pages.
     #if XNN_PLATFORM_WINDOWS
       // We cannot selectively release pages inside the region of pages, so just decommit them.
       if (!VirtualFree((void*) unused_start, unused_capacity, MEM_DECOMMIT)) {
         xnn_log_error("failed to unmap code/weights buffer, error code: %" PRIu32, (uint32_t) GetLastError());
         return xnn_status_invalid_state;
       }
       *capacity = page_aligned_size;
     #elif !XNN_PLATFORM_WEB
       // Web does not support partial unmapping.
       if (munmap((void*) unused_start, unused_capacity) == -1) {
         xnn_log_error("failed to unmap code/weights buffer, error code: %d", errno);
         return xnn_status_invalid_state;
       }
       *capacity = page_aligned_size;
     #else
       if (unused_capacity == *capacity) {
         if (munmap((void*) unused_start, unused_capacity) == -1) {
           xnn_log_error("failed to unmap code/weights buffer, error code: %d", errno);
           return xnn_status_invalid_state;
         } else {
           *capacity = 0;
         }
       }
     #endif
   }

   return xnn_status_success;
 }

 enum xnn_memory_permission {
   xnn_memory_permission_read_only,
   xnn_memory_permission_read_execute,
 };

 static enum xnn_status set_memory_permission(void* start, size_t size, enum xnn_memory_permission permission) {
   #if XNN_PLATFORM_WINDOWS
     DWORD old = 0, prot = 0;
     switch (permission) {
       case xnn_memory_permission_read_only:
         prot = PAGE_READONLY;
         break;
       case xnn_memory_permission_read_execute:
         prot = PAGE_EXECUTE_READ;
         break;
       default:
         XNN_UNREACHABLE;
     }
     if (!VirtualProtect(start, size, prot, &old)) {
       xnn_log_error(
         "failed to set memory permission (%d), error code: %" PRIu32, permission, (uint32_t) GetLastError());
       return xnn_status_invalid_state;
     }
   #elif XNN_PLATFORM_WEB
     // Memory protection not supported on Web.
     return xnn_status_success;
   #else
     int prot = 0;
     switch (permission) {
       case xnn_memory_permission_read_only:
         prot = PROT_READ;
         break;
       case xnn_memory_permission_read_execute:
         prot = PROT_READ | PROT_EXEC;
         break;
       default:
         XNN_UNREACHABLE;
     }
     if (mprotect(start, size, prot) == -1) {
       xnn_log_error("failed to set memory permission (%d), error code: %d", permission, errno);
       return xnn_status_invalid_state;
     }
   #endif
   return xnn_status_success;
 }

 #if XNN_PLATFORM_JIT
 enum xnn_status xnn_finalize_code_memory(struct xnn_code_buffer* buf) {
   enum xnn_status status;
   status = release_unused_memory(buf->size, buf->start, &buf->capacity);
   if (status != xnn_status_success) {
     return status;
   }

   if (buf->capacity == 0) {
     return xnn_status_success;
   }

   // Flush icache, do it before changing permissions due to bugs on older ARM64 kernels.
   #if (XNN_ARCH_ARM || XNN_ARCH_ARM64) && XNN_PLATFORM_JIT
     // iOS toolchain doesn't support this, use sys_icache_invalidate, when we support iOS.
     __builtin___clear_cache(buf->start, (void*) ((uint8_t*) buf->start + buf->capacity));
   #endif  // (XNN_ARCH_ARM || XNN_ARCH_ARM64) && !XNN_PLATFORM_IOS

   // Set permissions to RX (no write).
   #if XNN_PLATFORM_WINDOWS
     DWORD old = 0;
     if (!VirtualProtect(buf->start, buf->size, PAGE_EXECUTE_READ, &old)) {
       xnn_log_error("failed to make code buffer read+execute, error code: %" PRIu32, (uint32_t) GetLastError());
       return xnn_status_invalid_state;
     }
   #else
     if (mprotect(buf->start, buf->size, PROT_READ | PROT_EXEC) == -1) {
       xnn_log_error("failed to make code buffer read+execute, error code: %d", errno);
       return xnn_status_invalid_state;
     }
   #endif
   return set_memory_permission(buf->start, buf->size, xnn_memory_permission_read_execute);
 }
 #endif  // XNN_PLATFORM_JIT

 enum xnn_status xnn_release_code_memory(struct xnn_code_buffer* buf) {
   if (buf->capacity == 0) {
     return xnn_status_success;
   }
   const enum xnn_status status = release_memory(buf->start, buf->capacity);
   if (status != xnn_status_success) {
     return status;
   }
   memset(buf, 0, sizeof(struct xnn_code_buffer));
   return xnn_status_success;
 }

 enum xnn_status xnn_reserve_code_memory(struct xnn_code_buffer* buf, size_t n) {
   if (buf->size + n <= buf->capacity) {
     return xnn_status_success;
   }
   xnn_log_debug("reserving code memory of size %zu", n);

   size_t new_capacity = 0;
   void* new_start = resize_buffer(buf->start, buf->size, buf->capacity, buf->size + n, &new_capacity);
   if (new_start == NULL) {
     xnn_log_error("failed to reserve code memory");
     return xnn_status_out_of_memory;
   }
   buf->start = new_start;
   buf->capacity = new_capacity;
   return xnn_status_success;
 }

 enum xnn_status xnn_allocate_weights_memory(struct xnn_weights_buffer* buf, size_t size) {
   memset(buf, 0, sizeof(struct xnn_weights_buffer));
   size_t page_aligned_size = round_up_po2(size, xnn_params.page_size);
   buf->start = allocate_buffer(page_aligned_size);
   if (buf->start == NULL) {
     return xnn_status_out_of_memory;
   }

   buf->size = 0;
   buf->capacity = page_aligned_size;
   return xnn_status_success;
 }

 enum xnn_status xnn_release_weights_memory(struct xnn_weights_buffer* buf) {
   if (buf->capacity == 0) {
     return xnn_status_success;
   }
   enum xnn_status status = release_memory(buf->start, buf->capacity);
   if (status != xnn_status_success) {
     return status;
   }
   memset(buf, 0, sizeof(struct xnn_code_buffer));
   return xnn_status_success;
 }

 enum xnn_status xnn_reserve_weights_memory(struct xnn_weights_buffer* buf, size_t n) {
   if (buf->size + n <= buf->capacity) {
     xnn_log_debug("reserving weights memory of size %zu without growing buffer", n);
     return xnn_status_success;
   }

   size_t new_capacity = 0;
   void* new_start = resize_buffer(buf->start, buf->size, buf->capacity, buf->size + n, &new_capacity);
   if (new_start == NULL) {
     xnn_log_error("failed to reserve weights memory");
     return xnn_status_out_of_memory;
   }
   buf->start = new_start;
   buf->capacity = new_capacity;

   return xnn_status_success;
 }

 enum xnn_status xnn_finalize_weights_memory(struct xnn_weights_buffer* buf) {
   enum xnn_status status;
   status = release_unused_memory(buf->size, buf->start, &buf->capacity);
   if (status != xnn_status_success) {
     return status;
   }

   if (buf->capacity == 0) {
     return xnn_status_success;
   }

   return set_memory_permission(buf->start, buf->size, xnn_memory_permission_read_only);
 }
	// Copyright 2021 Google LLC
	//
	// This source code is licensed under the BSD-style license found in the
	// LICENSE file in the root directory of this source tree.

	// Include first for the platform detection macros.
	#include "xnnpack/common.h"

	#if XNN_PLATFORM_WINDOWS
	#ifndef WIN32_LEAN_AND_MEAN
	#define WIN32_LEAN_AND_MEAN
	#endif
	#include <windows.h>
	#else
	// This define needs to come first because errno include features.h and would have defined macros that lead to
	// sys/mman.h not having mremap.
	#if !defined(_GNU_SOURCE)
	#define _GNU_SOURCE
	#endif
	#include <errno.h>
	#include <sys/mman.h>
	#include <unistd.h>
	#endif

	#include <stddef.h>
	#include <stdint.h>
	#include <xnnpack.h>

	#include "xnnpack/allocator.h"
	#include "xnnpack/log.h"
	#include "xnnpack/math.h"
	#include "xnnpack/params.h"

	// Helpers to allocate/mmap and release memory used by both code and weights cache.

	// Maps `size` bytes of memory, returns pointer to allocation, NULL if failed.
	static void* allocate_buffer(size_t size) {
	xnn_log_debug("allocating buffer of size %zu", size);
	assert(size == round_up_po2(size, xnn_params.page_size));
	#if XNN_PLATFORM_WINDOWS
	void* p = VirtualAlloc(NULL, size, MEM_COMMIT \| MEM_RESERVE, PAGE_READWRITE);
	if (p == NULL) {
	xnn_log_error("failed to allocate %zu bytes for code/weights buffer, error code: %" PRIu32,
	size, (uint32_t) GetLastError());
	return NULL;
	}
	#else
	void* p = mmap(NULL, size, PROT_READ \| PROT_WRITE, MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	if (p == MAP_FAILED) {
	xnn_log_error("failed to allocate %zu bytes for code/weights buffer, error code: %d", size, errno);
	return NULL;
	}
	#endif
	return p;
	}

	// Releases memory previously mapped by `allocate_buffer`, returns xnn_status_success on success.
	static enum xnn_status release_memory(void* start, size_t capacity) {
	#if XNN_PLATFORM_WINDOWS
	// We only decommited any unused capacity, so we release all of it now.
	if (!VirtualFree(start, 0, MEM_RELEASE)) {
	xnn_log_error("failed to release code/weights buffer, error code: %" PRIu32, (uint32_t) GetLastError());
	return xnn_status_invalid_state;
	}
	#else
	if (munmap(start, capacity) == -1) {
	xnn_log_error("failed to release code/weights buffer, error code: %d", errno);
	return xnn_status_invalid_state;
	}
	#endif
	return xnn_status_success;
	}

	// Resize a buffer at old_pointer of size old_bytes to new_size. The actual new size of the resized buffer is written to
	// new_capacity_out, which can be >= new_size due to page alignment requirements.
	// Returns a pointer to a buffer which might be the same as old_pointer if we can remap virtual memory, otherwise we
	// allocate a new buffer and copy contents of old_buffer over.
	static void* resize_buffer(
	void* old_pointer, size_t old_size, size_t old_capacity, size_t new_size, size_t* new_capacity_out)
	{
	size_t new_capacity = round_up_po2(new_size, xnn_params.page_size);
	#if XNN_PLATFORM_LINUX
	void* new_pointer = mremap(old_pointer, old_size, new_capacity, MREMAP_MAYMOVE, NULL);
	if (new_pointer == MAP_FAILED) {
	xnn_log_error("mremap failed with errno: %d", errno);
	return NULL;
	}
	xnn_log_debug("resize_buffer: remap, old capacity %zu to new capacity %zu", old_capacity, new_capacity);
	#else
	void* new_pointer = allocate_buffer(new_capacity);
	if (new_pointer == NULL) {
	xnn_log_error("allocate_buffer failed");
	return NULL;
	}
	memcpy(new_pointer, old_pointer, old_size);
	// Release old code_buffer.
	enum xnn_status status = release_memory(old_pointer, old_capacity);
	if (status != xnn_status_success) {
	xnn_log_error("releasing old buffer failed, this could be a leak of %zu bytes", old_capacity);
	// Log but proceed as per normal since we successfully allocated a new memory that can be used by the caller.
	}
	xnn_log_debug("resize_buffer: allocate memory, old capacity %zu to new capacity %zu", old_capacity, new_capacity);
	#endif
	*new_capacity_out = new_capacity;
	return new_pointer;
	}

	enum xnn_status xnn_allocate_code_memory(struct xnn_code_buffer* buf, size_t size) {
	memset(buf, 0, sizeof(struct xnn_code_buffer));
	size_t page_aligned_size = round_up_po2(size, xnn_params.page_size);
	buf->start = allocate_buffer(page_aligned_size);
	if (buf->start == NULL) {
	return xnn_status_out_of_memory;
	}

	buf->size = 0;
	buf->capacity = page_aligned_size;
	return xnn_status_success;
	}

	// Releases unused memory. Will write the new capacity to `capacity`.
	static enum xnn_status release_unused_memory(size_t size, void* start, size_t* capacity) {
	// Release all unused pages.
	const size_t page_aligned_size = round_up_po2(size, xnn_params.page_size);
	const uint8_t* mem_start = (uint8_t*) start;
	const uint8_t* unused_start = mem_start + page_aligned_size;
	assert(*capacity >= page_aligned_size);
	const size_t unused_capacity = *capacity - page_aligned_size;

	xnn_log_debug("releasing memory, start %p, used: %zu, capacity: %zu, unused %zu", mem_start, size, *capacity,
	unused_capacity);

	if (unused_capacity != 0) {
	// Free unused pages.
	#if XNN_PLATFORM_WINDOWS
	// We cannot selectively release pages inside the region of pages, so just decommit them.
	if (!VirtualFree((void*) unused_start, unused_capacity, MEM_DECOMMIT)) {
	xnn_log_error("failed to unmap code/weights buffer, error code: %" PRIu32, (uint32_t) GetLastError());
	return xnn_status_invalid_state;
	}
	*capacity = page_aligned_size;
	#elif !XNN_PLATFORM_WEB
	// Web does not support partial unmapping.
	if (munmap((void*) unused_start, unused_capacity) == -1) {
	xnn_log_error("failed to unmap code/weights buffer, error code: %d", errno);
	return xnn_status_invalid_state;
	}
	*capacity = page_aligned_size;
	#else
	if (unused_capacity == *capacity) {
	if (munmap((void*) unused_start, unused_capacity) == -1) {
	xnn_log_error("failed to unmap code/weights buffer, error code: %d", errno);
	return xnn_status_invalid_state;
	} else {
	*capacity = 0;
	}
	}
	#endif
	}

	return xnn_status_success;
	}

	enum xnn_memory_permission {
	xnn_memory_permission_read_only,
	xnn_memory_permission_read_execute,
	};

	static enum xnn_status set_memory_permission(void* start, size_t size, enum xnn_memory_permission permission) {
	#if XNN_PLATFORM_WINDOWS
	DWORD old = 0, prot = 0;
	switch (permission) {
	case xnn_memory_permission_read_only:
	prot = PAGE_READONLY;
	break;
	case xnn_memory_permission_read_execute:
	prot = PAGE_EXECUTE_READ;
	break;
	default:
	XNN_UNREACHABLE;
	}
	if (!VirtualProtect(start, size, prot, &old)) {
	xnn_log_error(
	"failed to set memory permission (%d), error code: %" PRIu32, permission, (uint32_t) GetLastError());
	return xnn_status_invalid_state;
	}
	#elif XNN_PLATFORM_WEB
	// Memory protection not supported on Web.
	return xnn_status_success;
	#else
	int prot = 0;
	switch (permission) {
	case xnn_memory_permission_read_only:
	prot = PROT_READ;
	break;
	case xnn_memory_permission_read_execute:
	prot = PROT_READ \| PROT_EXEC;
	break;
	default:
	XNN_UNREACHABLE;
	}
	if (mprotect(start, size, prot) == -1) {
	xnn_log_error("failed to set memory permission (%d), error code: %d", permission, errno);
	return xnn_status_invalid_state;
	}
	#endif
	return xnn_status_success;
	}

	#if XNN_PLATFORM_JIT
	enum xnn_status xnn_finalize_code_memory(struct xnn_code_buffer* buf) {
	enum xnn_status status;
	status = release_unused_memory(buf->size, buf->start, &buf->capacity);
	if (status != xnn_status_success) {
	return status;
	}

	if (buf->capacity == 0) {
	return xnn_status_success;
	}

	// Flush icache, do it before changing permissions due to bugs on older ARM64 kernels.
	#if (XNN_ARCH_ARM \|\| XNN_ARCH_ARM64) && XNN_PLATFORM_JIT
	// iOS toolchain doesn't support this, use sys_icache_invalidate, when we support iOS.
	__builtin___clear_cache(buf->start, (void) ((uint8_t) buf->start + buf->capacity));
	#endif // (XNN_ARCH_ARM \|\| XNN_ARCH_ARM64) && !XNN_PLATFORM_IOS

	// Set permissions to RX (no write).
	#if XNN_PLATFORM_WINDOWS
	DWORD old = 0;
	if (!VirtualProtect(buf->start, buf->size, PAGE_EXECUTE_READ, &old)) {
	xnn_log_error("failed to make code buffer read+execute, error code: %" PRIu32, (uint32_t) GetLastError());
	return xnn_status_invalid_state;
	}
	#else
	if (mprotect(buf->start, buf->size, PROT_READ \| PROT_EXEC) == -1) {
	xnn_log_error("failed to make code buffer read+execute, error code: %d", errno);
	return xnn_status_invalid_state;
	}
	#endif
	return set_memory_permission(buf->start, buf->size, xnn_memory_permission_read_execute);
	}
	#endif // XNN_PLATFORM_JIT

	enum xnn_status xnn_release_code_memory(struct xnn_code_buffer* buf) {
	if (buf->capacity == 0) {
	return xnn_status_success;
	}
	const enum xnn_status status = release_memory(buf->start, buf->capacity);
	if (status != xnn_status_success) {
	return status;
	}
	memset(buf, 0, sizeof(struct xnn_code_buffer));
	return xnn_status_success;
	}

	enum xnn_status xnn_reserve_code_memory(struct xnn_code_buffer* buf, size_t n) {
	if (buf->size + n <= buf->capacity) {
	return xnn_status_success;
	}
	xnn_log_debug("reserving code memory of size %zu", n);

	size_t new_capacity = 0;
	void* new_start = resize_buffer(buf->start, buf->size, buf->capacity, buf->size + n, &new_capacity);
	if (new_start == NULL) {
	xnn_log_error("failed to reserve code memory");
	return xnn_status_out_of_memory;
	}
	buf->start = new_start;
	buf->capacity = new_capacity;
	return xnn_status_success;
	}

	enum xnn_status xnn_allocate_weights_memory(struct xnn_weights_buffer* buf, size_t size) {
	memset(buf, 0, sizeof(struct xnn_weights_buffer));
	size_t page_aligned_size = round_up_po2(size, xnn_params.page_size);
	buf->start = allocate_buffer(page_aligned_size);
	if (buf->start == NULL) {
	return xnn_status_out_of_memory;
	}

	buf->size = 0;
	buf->capacity = page_aligned_size;
	return xnn_status_success;
	}

	enum xnn_status xnn_release_weights_memory(struct xnn_weights_buffer* buf) {
	if (buf->capacity == 0) {
	return xnn_status_success;
	}
	enum xnn_status status = release_memory(buf->start, buf->capacity);
	if (status != xnn_status_success) {
	return status;
	}
	memset(buf, 0, sizeof(struct xnn_code_buffer));
	return xnn_status_success;
	}

	enum xnn_status xnn_reserve_weights_memory(struct xnn_weights_buffer* buf, size_t n) {
	if (buf->size + n <= buf->capacity) {
	xnn_log_debug("reserving weights memory of size %zu without growing buffer", n);
	return xnn_status_success;
	}

	size_t new_capacity = 0;
	void* new_start = resize_buffer(buf->start, buf->size, buf->capacity, buf->size + n, &new_capacity);
	if (new_start == NULL) {
	xnn_log_error("failed to reserve weights memory");
	return xnn_status_out_of_memory;
	}
	buf->start = new_start;
	buf->capacity = new_capacity;

	return xnn_status_success;
	}

	enum xnn_status xnn_finalize_weights_memory(struct xnn_weights_buffer* buf) {
	enum xnn_status status;
	status = release_unused_memory(buf->size, buf->start, &buf->capacity);
	if (status != xnn_status_success) {
	return status;
	}

	if (buf->capacity == 0) {
	return xnn_status_success;
	}

	return set_memory_permission(buf->start, buf->size, xnn_memory_permission_read_only);
	}