polar-memory-pool-page.c

/* Internal API: memory pool page type for polar-objc.
   Copyright (C) 2022-2025 Michael Malicoat <[email protected]>
 
   This file is part of polar-objc.
 
   polar-objc is free software; you can redistribute it and/or modify it under the terms of the GNU General Public
   License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
 
   polar-objc is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
   details.
 
   You should have received a copy of the GNU General Public License along with this program; see the file LICENSE.  If
   not, see <http://www.gnu.org/licenses/>.
*/
// polar_memory_pool_page **********************************************************************************************
// Private =============================================================================================================
 
// This variable is initialized in polar_memory_pool_page_get_type()
static polar_memory_pool_page_class class_polar_memory_pool_page;
 
// This variable is initialized in _polar_memory_pool_page_class_init()
static polar_runtime_object_class *superclass_polar_memory_pool_page = NULL;
 
// ---------------------------------------------------------------------------------------------------------------------
 
POLAR_FUNCTION_INTERNAL polar_memory_pool_page *
polar_memory_pool_page_allocate_sized( polar_memory_pool_page_class *self, size_t size_page_desired )
{
  polar_memory_pool_page *result;
  size_t size_type_instance, size_page_allocated;
 
  assert( POLAR_IS_MEMORY_POOL_PAGE_CLASS(self) );
 
  size_type_instance = POLAR_RUNTIME_OBJECT_CLASS(self)->type_definition->size_type_instance;
 
  if( size_page_desired != (size_t)-1 )
  {
    assert( size_page_desired >= size_type_instance );
  }
 
  else
    size_page_desired = size_type_instance;
 
  result = NULL;
  size_page_allocated = polar_platform_vmem_map( &result, (size_t)size_page_desired, NO );
 
  if( result != NULL )
  {
    result->page_size = size_page_allocated;
    polar_runtime_object_preallocated_init(result, POLAR_RUNTIME_OBJECT_CLASS(self)->id_type_class, NO);    
  }
 
  else
    POLAR_RUNTIME_ERROR->memory_exhausted(POLAR_RUNTIME_OBJECT_CLASS(self)->type_definition->size_type_instance);
 
  return result;
}
 
// ---------------------------------------------------------------------------------------------------------------------
 
POLAR_FUNCTION_INTERNAL polar_memory_pool_page *
_polar_memory_pool_page_init( polar_memory_pool_page *self )
{
  size_t size_instance;
 
  // Chain up first
  self = (polar_memory_pool_page *)
    POLAR_RUNTIME_OBJECT_CLASS(superclass_polar_memory_pool_page)->init( (polar_runtime_object *)self );
 
  if( self != NULL )
  {
    size_instance = polar_runtime_object_get_size((polar_runtime_object *)self);
    self->page_break = ( (char *)self + OBJC_SIZE_ALIGN(size_instance, OBJC_SIZEOF_POINTER) );
  }
 
  return self;
}
 
POLAR_FUNCTION_INTERNAL void
_polar_memory_pool_page_deallocate( polar_memory_pool_page *self )
{
  polar_platform_vmem_unmap(self, self->page_size);
}
 
POLAR_FUNCTION_INTERNAL polar_memory_pool_page *
_polar_memory_pool_page_allocate( polar_memory_pool_page_class *self )
{
  return polar_memory_pool_page_allocate_sized(self, (size_t)-1);
}
 
POLAR_FUNCTION_INTERNAL void
_polar_memory_pool_page_clear( polar_memory_pool_page *self )
{
  size_t count_bytes_committed_old, size_instance;
 
  size_instance = polar_runtime_object_get_size( (polar_runtime_object *)self );
  size_instance = OBJC_SIZE_ALIGN(size_instance, OBJC_SIZEOF_POINTER);
 
  count_bytes_committed_old = polar_memory_pool_page_get_bytes_committed(self) - size_instance;
  self->page_break = ( (char *)self + size_instance );
 
  objc_memzero( self->page_break, count_bytes_committed_old );
}
 
POLAR_FUNCTION_INTERNAL void
_polar_memory_pool_page_class_init( polar_memory_pool_page_class *self )
{
  // Acquire our superclass
  superclass_polar_memory_pool_page = POLAR_RUNTIME_OBJECT_CLASS(self)->class_superclass;
 
  // Establish our virtual methods
  ( (polar_runtime_object_class *)self )->init = (polar_func_runtime_object_lifecycle)_polar_memory_pool_page_init;
 
  ( (polar_runtime_object_class *)self )->deallocate =
    (polar_func_runtime_object_deallocate)_polar_memory_pool_page_deallocate;
 
  ( (polar_runtime_object_class *)self )->allocate =
    (polar_func_runtime_object_allocate)_polar_memory_pool_page_allocate;
 
  self->clear = _polar_memory_pool_page_clear;
}
 
static struct polar_internal_type_info pti_polar_memory_pool_page =
{
  .name_type          = "polar_memory_pool_page",
  .size_type_instance = sizeof(polar_memory_pool_page),
  .size_type_class    = sizeof(polar_memory_pool_page_class),
  .type_class_init    = (polar_func_runtime_object_class_lifecycle)_polar_memory_pool_page_class_init
};
 
// Public ==============================================================================================================
 
POLAR_FUNCTION_INTERNAL OBJC_FUNCTION_CONSTANT polar_internal_type
polar_memory_pool_page_get_type( void )
{
  static polar_internal_type pt_polar_memory_pool_page = POLAR_INTERNAL_TYPE_INVALID;
 
  if( pt_polar_memory_pool_page != POLAR_INTERNAL_TYPE_INVALID )
    return pt_polar_memory_pool_page;
 
  pt_polar_memory_pool_page = polar_internal_type_init( POLAR_TYPE_LIST_NODE, &class_polar_memory_pool_page,
                                                        &pti_polar_memory_pool_page );
 
  return pt_polar_memory_pool_page;
}
 
POLAR_FUNCTION_INTERNAL OBJC_RETURNS_VALID_POINTER polar_memory_pool_page *
polar_memory_pool_page_new( size_t size_page_desired )
{
  polar_memory_pool_page_class *type_class;
 
  assert( size_page_desired >= sizeof(polar_memory_pool_page) );
 
  type_class = (polar_memory_pool_page_class *)polar_internal_type_get_class(POLAR_TYPE_MEMORY_POOL_PAGE);
  return polar_memory_pool_page_allocate_sized(type_class, size_page_desired );
}
 
POLAR_FUNCTION_INTERNAL OBJC_FUNCTION_HOTSPOT void *
polar_memory_pool_page_sbrk( polar_memory_pool_page *self, size_t count_bytes_increment )
{
  char *result;
 
  assert( POLAR_IS_MEMORY_POOL_PAGE(self) );
  assert( count_bytes_increment > 0 );
 
  result = NULL;
 
  if( polar_memory_pool_page_test_fit(self, count_bytes_increment) )
  {
    result = self->page_break;
    self->page_break += count_bytes_increment;
  }
 
  return result;
}