polar-runtime-service-thread.c

/* Internal API: runtime service thread 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/>.
*/
 
// Private =============================================================================================================
 
#define POLAR_MSG_SERVICE_READY 0xFFFFFF51
#define POLAR_MSG_SERVICE_SHUTDOWN 0xFFFFFF5F
 
// These variables are all initialized in polar_runtime_service_thread_init()
thrd_t polar_id_main_thread = (thrd_t)0;
thrd_t polar_id_rts_thread = (thrd_t)0;
polar_thread_message_queue *polar_inbox_rts_thread = NULL;
 
// This variable is initialized in polar_runtime_service_thread_init()
static polar_thread_message_queue *polar_inbox_main_thread = NULL;
 
polar_runtime_service *polar_array_runtime_services[ POLAR_ID_SERVICE_LAST ] =
{
  NULL,
 
  // These are replaced with the corresponding instance of each class by polar_runtime_service_thread_init_services()
  (polar_runtime_service *)polar_runtime_service_dispatch_get_type,
  (polar_runtime_service *)polar_runtime_service_memory_disposal_get_type,
  (polar_runtime_service *)polar_runtime_service_module_get_type,
  (polar_runtime_service *)polar_runtime_service_selector_get_type,
  (polar_runtime_service *)polar_runtime_service_thread_sync_get_type,
  (polar_runtime_service *)polar_runtime_service_type_registry_get_type,
  (polar_runtime_service *)polar_runtime_service_type_work_get_type
};
 
// Called by polar_runtime_service_thread()
POLAR_FUNCTION_INTERNAL void
polar_runtime_service_thread_init_services( void )
{
  polar_func_internal_type_get_type service_get_type;
  intptr_t i;
 
  for( i = POLAR_ID_SERVICE_FIRST; i < POLAR_ID_SERVICE_LAST; i++ )
  {
    service_get_type = (polar_func_internal_type_get_type)polar_array_runtime_services[i];
    polar_array_runtime_services[i] = (polar_runtime_service *)polar_runtime_object_new( service_get_type() );
  }
  
  POLAR_DEBUG_FUNCTION_END;  
}
 
// Called by polar_runtime_service_thread()
POLAR_FUNCTION_INTERNAL void
polar_runtime_service_thread_finalize_services( void )
{
  polar_runtime_object *service_current;
  intptr_t i;
 
  for( i = (POLAR_ID_SERVICE_LAST - 1); i > POLAR_ID_SERVICE_NONE; i-- )
  {
    service_current = (polar_runtime_object *)( polar_array_runtime_services[i] );
 
    if( service_current != NULL )
    {
      polar_runtime_object_free(service_current);
      polar_array_runtime_services[i] = NULL;
    }
  }
  
  POLAR_DEBUG_FUNCTION_END;  
}
 
OBJC_FUNCTION_HOTSPOT void *
polar_runtime_service_thread( void *thread_entry_data OBJC_IGNORE_UNUSED )
{
  polar_thread_message *service_request;
  uintptr_t id_service_desired, id_operation_desired;
 
  // Initialize our services
  polar_runtime_service_thread_init_services();
 
  // Let the main thread know we're ready to receive messages
  service_request = polar_thread_message_new(POLAR_MSG_SERVICE_READY, 0, NULL);
  polar_thread_message_send(service_request, polar_inbox_main_thread);
 
  // Wait for work to become available
  service_request = polar_thread_message_queue_message_wait(polar_inbox_rts_thread);
  while( service_request->subject_message != POLAR_MSG_SERVICE_SHUTDOWN )
  {
    // Handle the request
    id_service_desired = ( service_request->subject_message >> POLAR_SHIFT_SERVICE_REQUEST );
    assert( id_service_desired > POLAR_ID_SERVICE_NONE );
    assert( id_service_desired < POLAR_ID_SERVICE_LAST );
 
    id_operation_desired = ( service_request->subject_message & POLAR_MASK_REQUEST_OPERATION );
 
    polar_runtime_service_request_handle( polar_array_runtime_services[id_service_desired], id_operation_desired,
                                          service_request, service_request->message_data );
 
    // Wait for work to become available
    service_request = polar_thread_message_queue_message_wait(polar_inbox_rts_thread);
  }
 
  // Free the "shutdown" message
  polar_runtime_object_free( (polar_runtime_object *)service_request );
 
  // Finalize our services
  polar_runtime_service_thread_finalize_services();
 
  // Return NULL and end the thread
  return NULL;
}
 
// Public ==============================================================================================================
 
// Called by polar_init()
POLAR_FUNCTION_INTERNAL intptr_t
polar_runtime_service_thread_init( void )
{
  polar_thread_message *message_service_thread_ready;
 
  // Establish a message queue for the main thread
  polar_id_main_thread = thrd_current();
  polar_inbox_main_thread = polar_thread_current_get_inbox();
 
  // Establish a message queue for the runtime service thread
  polar_inbox_rts_thread = polar_thread_message_queue_new(polar_id_main_thread);
 
  // Spin off the runtime service thread
  polar_thread_split( &polar_id_rts_thread, (polar_func_thread_enter)polar_runtime_service_thread, NULL,
                      polar_inbox_rts_thread );
 
  if( polar_id_rts_thread != (thrd_t) 0 )
    ;
 
  else
    return -1;
 
  // Wait for the runtime service thread to report that it's ready for work
  message_service_thread_ready = polar_thread_message_queue_message_wait(polar_inbox_main_thread);
  assert( message_service_thread_ready->subject_message == POLAR_MSG_SERVICE_READY );
 
  polar_runtime_object_free( (polar_runtime_object *)message_service_thread_ready );
 
  POLAR_DEBUG_FUNCTION_END;
 
  return 0;
}
 
// Called by polar_finalize()
POLAR_FUNCTION_INTERNAL void
polar_runtime_service_thread_finalize( void )
{
  polar_thread_message *message_service_thread_shutdown;
 
  if( polar_id_rts_thread != (thrd_t)0 )
  {
    // Shut down the runtime service thread
    message_service_thread_shutdown = polar_thread_message_new(POLAR_MSG_SERVICE_SHUTDOWN, 0, NULL);
    polar_thread_message_send(message_service_thread_shutdown, polar_inbox_rts_thread);
 
    // Wait for the service thread to shut down gracefully
    thrd_join(polar_id_rts_thread, NULL);
  }
 
  POLAR_DEBUG_FUNCTION_END;
}