polar-windows-platform-threading.c

/* Internal API: low-level Windows threading routines 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/>.
*/
 
 
// Public ==============================================================================================================

 
// Condition variables -------------------------------------------------------------------------------------------------
 
POLAR_FUNCTION_INTERNAL intptr_t
cnd_init( cnd_t *p_cond )
{
  assert( p_cond != NULL );
 
  p_cond->event_condition = CreateEvent(NULL, NO, NO, NULL);
  if( p_cond->event_condition != (HANDLE)0 )
    return mtx_init( &p_cond->lock_condition, mtx_recursive );
 
  else
    return -1;
}
 
POLAR_FUNCTION_INTERNAL void
cnd_destroy( cnd_t *p_cond )
{
  HANDLE event_condition;
 
  if( p_cond != NULL )
    ;
 
  else
    return;
 
  assert( p_cond->count_waiters == 0 );
 
  if( p_cond->event_condition != (HANDLE)0 )
  {
    mtx_lock( &p_cond->lock_condition );
 
      event_condition = p_cond->event_condition;
      p_cond->event_condition = (HANDLE)0;
 
    mtx_unlock( &p_cond->lock_condition );
    mtx_destroy( &p_cond->lock_condition );
 
    CloseHandle(event_condition);
  }
}
 
POLAR_FUNCTION_INTERNAL intptr_t
cnd_broadcast( cnd_t *p_cond )
{
  HANDLE event_condition;
  intptr_t count_waiters;
 
  assert( p_cond != NULL );
 
  mtx_lock( &p_cond->lock_condition );
 
  event_condition = p_cond->event_condition;
  count_waiters = p_cond->count_waiters;
  p_cond->count_waiters = 0;
 
  mtx_unlock( &p_cond->lock_condition );
 
  if( event_condition != (HANDLE)0 )
  {
    for( ; count_waiters > 0; count_waiters-- )
    {
      // According to Microsoft, this releases exactly one thread at a time when used with an auto-reset event
      if( SetEvent(event_condition) )
        ;
 
      else
        return -1;
    }
 
    return 0;
  }
 
  else
    return -1;
}
 
POLAR_FUNCTION_INTERNAL intptr_t
cnd_signal( cnd_t *p_cond )
{
  intptr_t result;
 
  assert( p_cond != NULL );
 
  result = -1;
 
  mtx_lock( &p_cond->lock_condition );
 
  if( p_cond->event_condition != (HANDLE)0 )
  {
    if( p_cond->count_waiters > 0 )
    {
      if( SetEvent(p_cond->event_condition) )
      {
        p_cond->count_waiters--;
        result = 0;
      }
    }
 
    else
      result = 0;
  }
 
  mtx_unlock( &p_cond->lock_condition );
 
  return result;
}
 
POLAR_FUNCTION_INTERNAL intptr_t
cnd_wait( cnd_t *p_cond, mtx_t *p_mutex )
{
  HANDLE event_condition;
 
  assert( p_cond != NULL );
 
  mtx_lock( &p_cond->lock_condition );
 
  event_condition = p_cond->event_condition;
  if( event_condition != (HANDLE)0 )
  {
    p_cond->count_waiters++;
    mtx_unlock(p_mutex);
  }
 
  mtx_unlock( &p_cond->lock_condition );
 
  if( (event_condition != (HANDLE)0) && (WaitForSingleObject(event_condition, INFINITE) == WAIT_OBJECT_0) )
    return mtx_lock(p_mutex);
 
  else
    return -1;
}
 
// Threading -----------------------------------------------------------------------------------------------------------
 
POLAR_FUNCTION_INTERNAL intptr_t
thrd_create( thrd_t *out_thread_id, thrd_start_t thread_func, void *thread_data )
{
  HANDLE handle_thread_new;
 
  assert( out_thread_id != NULL );
  assert( thread_func != NULL );
 
  *out_thread_id = (thrd_t)0;
 
  handle_thread_new = CreateThread(NULL, 0, thread_func, thread_data, 0, out_thread_id);
  if( handle_thread_new != (HANDLE)0 )
    return 0;
 
  else
    return -1;
}
 
POLAR_FUNCTION_INTERNAL intptr_t
thrd_join( thrd_t id_thread_target, intptr_t *__p_retval_unused OBJC_IGNORE_UNUSED )
{
  intptr_t result;
  HANDLE handle_thread_target;
 
  result = -1;
 
  handle_thread_target = OpenThread(SYNCHRONIZE, NO, id_thread_target);
  if( handle_thread_target != (HANDLE)0 )
  {
    if( WaitForSingleObject(handle_thread_target, INFINITE) == WAIT_OBJECT_0 )
      result = 0;
 
    CloseHandle(handle_thread_target);
  }
 
  return result;
}
 
// Threadvars ----------------------------------------------------------------------------------------------------------
 
POLAR_FUNCTION_INTERNAL intptr_t
tss_create( tss_t *out_tss_id, tss_dtor_t __func_destructor_unused OBJC_IGNORE_UNUSED )
{
  tss_t tvar_id_new;
 
  assert( out_tss_id != NULL );
 
  tvar_id_new = TlsAlloc();
  if( tvar_id_new != TLS_OUT_OF_INDEXES )
  {
    *out_tss_id = tvar_id_new;
    return 0;
  }
 
  else
    return -1;
}
 
// ---------------------------------------------------------------------------------------------------------------------
 
// Called by polar_init()
POLAR_FUNCTION_INTERNAL intptr_t
polar_platform_threading_init( void )
{
  // Nothing to do here
  POLAR_DEBUG_FUNCTION_END;
 
  return 0;
}
 
// Called by polar_finalize()
POLAR_FUNCTION_INTERNAL void
polar_platform_threading_finalize( void )
{
  // Nothing to do here
  POLAR_DEBUG_FUNCTION_END;
}