#include <windows.h>

Include dependency graph for magmawinthread.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	pthread_s
struct	pthread_cond_s

Macros
#define	PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) -1)
#define	PTHREAD_SCOPE_SYSTEM 1
#define	MAGMA_DLLPORT
#define	MAGMA_CDECL __cdecl

Typedefs
typedef struct pthread_s	pthread_t
typedef HANDLE	pthread_mutex_t
typedef int	pthread_mutexattr_t
typedef int	pthread_attr_t
typedef int	pthread_condattr_t
typedef struct pthread_cond_s	pthread_cond_t

Functions
MAGMA_DLLPORT pthread_t MAGMA_CDECL	pthread_self (void)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_mutex_init (pthread_mutex_t mutex, const pthread_mutexattr_t attr)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_mutex_destroy (pthread_mutex_t *mutex)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_mutex_lock (pthread_mutex_t *mutex)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_mutex_trylock (pthread_mutex_t *mutex)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_mutex_unlock (pthread_mutex_t *mutex)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_attr_init (pthread_attr_t *attr)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_attr_destroy (pthread_attr_t *attr)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_attr_setscope (pthread_attr_t *attr, int scope)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_create (pthread_t tid, const pthread_attr_t attr, void (start)(void ), void arg)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_cond_init (pthread_cond_t cond, const pthread_condattr_t attr)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_cond_destroy (pthread_cond_t *cond)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_cond_wait (pthread_cond_t cond, pthread_mutex_t mutex)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_cond_broadcast (pthread_cond_t *cond)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_join (pthread_t thread, void **value_ptr)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_equal (pthread_t thread1, pthread_t thread2)
MAGMA_DLLPORT int MAGMA_CDECL	pthread_setconcurrency (int)
MAGMA_DLLPORT unsigned int MAGMA_CDECL	pthread_self_id (void)

Macro Definition Documentation

#define MAGMA_CDECL __cdecl

Definition at line 54 of file magmawinthread.h.

#define MAGMA_DLLPORT

Definition at line 53 of file magmawinthread.h.

#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) -1)

Definition at line 49 of file magmawinthread.h.

#define PTHREAD_SCOPE_SYSTEM 1

Definition at line 51 of file magmawinthread.h.

Typedef Documentation

typedef int pthread_attr_t

Definition at line 37 of file magmawinthread.h.

typedef struct pthread_cond_s pthread_cond_t

typedef int pthread_condattr_t

Definition at line 38 of file magmawinthread.h.

typedef HANDLE pthread_mutex_t

Definition at line 35 of file magmawinthread.h.

typedef int pthread_mutexattr_t

Definition at line 36 of file magmawinthread.h.

typedef struct pthread_s pthread_t

Function Documentation

MAGMA_DLLPORT int MAGMA_CDECL pthread_attr_destroy ( pthread_attr_t * attr )

Definition at line 127 of file magmawinthread.c.

MAGMA_DLLPORT int MAGMA_CDECL pthread_attr_init ( pthread_attr_t * attr )

Definition at line 122 of file magmawinthread.c.

MAGMA_DLLPORT int MAGMA_CDECL pthread_attr_setscope	(	pthread_attr_t *	attr,
		int	scope
	)

Definition at line 132 of file magmawinthread.c.

                                                                                     {
  if (*attr != 1)
    return -1;
  if (scope != PTHREAD_SCOPE_SYSTEM)
    return -1;
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_cond_broadcast ( pthread_cond_t * cond )

Definition at line 239 of file magmawinthread.c.

                                                                           {
  int more_waiters = 0;
  /* This is needed to ensure exclusive access to "waitCount" */
  EnterCriticalSection (&cond->cs);
  if (cond->waitCount > 0) {
    /* always are broadcasting - no need for pthread_cond_singal() case */
    more_waiters = 1;
  }
  if (more_waiters) {
    /* this will wake up all the waiters atomically at once. */
    ReleaseSemaphore(cond->hSem, cond->waitCount, 0);
    LeaveCriticalSection(&cond->cs);
    /* Wait for all the awakened threads to acquire the counting semaphore. */
    WaitForSingleObject(cond->hEvt, INFINITE);
  } else
    LeaveCriticalSection(&cond->cs);
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_cond_destroy ( pthread_cond_t * cond )

Definition at line 197 of file magmawinthread.c.

                                                                         {
  DeleteCriticalSection( &cond->cs );
  CloseHandle( cond->hSem );
  CloseHandle( cond->hEvt );
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_cond_init	(	pthread_cond_t *	cond,
		const pthread_condattr_t *	attr
	)

Definition at line 183 of file magmawinthread.c.

                                                                                                      {
  InitializeCriticalSection( &cond->cs );
  cond->hSem = CreateSemaphore( NULL, /* no security attributes */
    0, /* initial count */
    LONG_MAX, /* maximum count*/
    NULL ); /* unnamed semaphore */
  cond->hEvt = CreateEvent( NULL, /* no security attributes */
    FALSE, /* reset to not-singaled automatically */
    FALSE, /* set initial status to not-signaled */
    NULL ); /* unnamed event */
  cond->waitCount = 0;
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_cond_wait	(	pthread_cond_t *	cond,
		pthread_mutex_t *	mutex
	)

Definition at line 204 of file magmawinthread.c.

                                                                                              {
  int last;
  if ( *mutex == PTHREAD_MUTEX_INITIALIZER ) pthread_mutex_check_for_static_initialization( mutex );
  /* Avoid race condition on waiting thread counter. */
  EnterCriticalSection(&cond->cs);
  cond->waitCount++;
  LeaveCriticalSection(&cond->cs);
  /* Releases _atomically_ the mutex and wait on the semaphore until
     pthread_cond_signal() or pthread_cond_broadcast() are called (by another thread). */
  SignalObjectAndWait(*mutex, cond->hSem, INFINITE, FALSE);
  /* Avoid race condition on waiting thread counter. */
  EnterCriticalSection(&cond->cs);
  cond->waitCount--; /* this thread doesn't wait any more */
  /* if this is the last thread to have waited */
  last = cond->waitCount == 0;
  LeaveCriticalSection(&cond->cs);
  /* If this thread is the last waiter thread during this particular broadcast
     then let all the other threads proceed. */
  if (last)
    /* This call ensures that two things happen atomically: signaling the hEvt event and
       waiting until "mutex" can be acquired. */
    SignalObjectAndWait(cond->hEvt, *mutex, INFINITE, FALSE);
  else
    WaitForSingleObject(*mutex, INFINITE); /* Upon return, this thread has to own "mutex". */
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_create	(	pthread_t *	tid,
		const pthread_attr_t *	attr,
		void ()(void *)	start,
		void *	arg
	)

Definition at line 152 of file magmawinthread.c.

                                                                                                                                {
  /* this assumes that the threads call the same function, always; it also assumes there
     is no race condition while assigning a pointer and using it from within threads
     (this assumption is fulfilled by creating the new thread in suspended state) */
  MAGMA_realThStart = start;
  thread->hThread = (HANDLE)_beginthreadex(
    NULL, /* default security */
    0, /* stack size: use the size of calling thread */
    MAGMA_winThStart,
    arg,
    CREATE_SUSPENDED,
    /*0,*/   /* the thread will run immedietally (rather than get suspended) */
    &thread->uThId );
  /* We need to make sure that _beginthreadex() returns to the parent thread first
     so we can safely fill up the members of the pthread_t structure without possible
     race conditions. If the new thread is created in supsended state we eliminate
     the race condition but now we have to resume the new thread. */
  ResumeThread( thread->hThread );
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_equal	(	pthread_t	thread1,
		pthread_t	thread2
	)

Definition at line 42 of file magmawinthread.c.

                                                                                  {
  if (thread1.uThId == thread2.uThId) // && thread1.hThread == thread2.hThread)
    return 1;
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_join	(	pthread_t	thread,
		void **	value_ptr
	)

Definition at line 177 of file magmawinthread.c.

                                                                               {
  WaitForSingleObject( thread.hThread, INFINITE );
  CloseHandle( thread.hThread );
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_mutex_destroy ( pthread_mutex_t * mutex )

Definition at line 117 of file magmawinthread.c.

                                                                            {
  CloseHandle( *mutex );
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_mutex_init	(	pthread_mutex_t *	mutex,
		const pthread_mutexattr_t *	attr
	)

no security atributes

not owned (initialy) by the creating thread

no name provided: cannot be shared between processes

no security atributes

not owned (initialy) by the creating thread

no name provided: cannot be shared between processes

Definition at line 48 of file magmawinthread.c.

                                                                                                           {
  *mutex =
  CreateMutex( NULL,  
               FALSE, 
               NULL   
  );
  return 0;
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_mutex_lock ( pthread_mutex_t * mutex )

the wait was succesful

the wait failed

thread killed during the wait

impossible because of INFINITE

the wait was succesful

the wait failed

thread killed during the wait

impossible because of INFINITE

Definition at line 72 of file magmawinthread.c.

                                                                         {
  DWORD rv;
  if ( *mutex == PTHREAD_MUTEX_INITIALIZER ) pthread_mutex_check_for_static_initialization( mutex );
  rv = WaitForSingleObject( *mutex, INFINITE );
  switch (rv) {
    case WAIT_OBJECT_0: 
      return 0;
    case WAIT_FAILED: 
      return -1;
    case WAIT_ABANDONED: 
      return -1;
    case WAIT_TIMEOUT: 
      return -1;
    default:
      return -1;
  }
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_mutex_trylock ( pthread_mutex_t * mutex )

the wait was succesful

the wait failed

thread killed during the wait

impossible because of INFINITE

the wait was succesful

the wait failed

thread killed during the wait

impossible because of INFINITE

Definition at line 91 of file magmawinthread.c.

                                                                            {
  DWORD rv;
  if ( *mutex == PTHREAD_MUTEX_INITIALIZER ) pthread_mutex_check_for_static_initialization( mutex );
  rv = WaitForSingleObject( *mutex, 0 );
  switch (rv) {
    case WAIT_OBJECT_0: 
      return 0;
    case WAIT_FAILED: 
      return -1;
    case WAIT_ABANDONED: 
      return -1;
    case WAIT_TIMEOUT: 
      return -1;
    default:
      return -1;
  }
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_mutex_unlock ( pthread_mutex_t * mutex )

Definition at line 110 of file magmawinthread.c.

                                                                           {
  if (! ReleaseMutex( *mutex ))
    return -1;
  return 0;
}

MAGMA_DLLPORT pthread_t MAGMA_CDECL pthread_self ( void )

Definition at line 34 of file magmawinthread.c.

                                                       {
  pthread_t pt;
  pt.hThread = GetCurrentThread();
  pt.uThId = GetCurrentThreadId();
  return pt;
}

MAGMA_DLLPORT unsigned int MAGMA_CDECL pthread_self_id ( void )

Definition at line 30 of file magmawinthread.c.

                                                             {
  return GetCurrentThreadId();
}

MAGMA_DLLPORT int MAGMA_CDECL pthread_setconcurrency ( int )

Definition at line 266 of file magmawinthread.c.

                                                                 {
  pthread_conclevel = level;
  return 0;
}

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

Typedef Documentation

Function Documentation