plank_Thread.h

/*
 -------------------------------------------------------------------------------
 This file is part of the Plink, Plonk, Plank libraries
  by Martin Robinson
 
 http://code.google.com/p/pl-nk/
 
 Copyright University of the West of England, Bristol 2011-14
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
 * Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
 * Neither the name of University of the West of England, Bristol nor 
   the names of its contributors may be used to endorse or promote products
   derived from this software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 DISCLAIMED. IN NO EVENT SHALL UNIVERSITY OF THE WEST OF ENGLAND, BRISTOL BE 
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
 OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
 This software makes use of third party libraries. For more information see:
 doc/license.txt included in the distribution.
 -------------------------------------------------------------------------------
 */

#ifndef PLANK_THREAD_H
#define PLANK_THREAD_H

#include "../containers/atomic/plank_Atomic.h"

PLANK_BEGIN_C_LINKAGE

typedef struct PlankThread* PlankThreadRef; 

#if PLANK_WIN
typedef PlankUI PlankThreadID;
#else
typedef PlankUL PlankThreadID;
#endif

typedef PlankResult (*PlankThreadFunction)(PlankThreadRef);

PlankResult pl_ThreadSleep (PlankD seconds);

PlankResult pl_ThreadYield();

PlankThreadID pl_ThreadCurrentID();

PlankThreadRef pl_Thread_CreateAndInit();

PlankThreadRef pl_Thread_Create();

PlankResult pl_Thread_Init (PlankThreadRef p);

PlankResult pl_Thread_DeInit (PlankThreadRef p);

PlankResult pl_Thread_Destroy (PlankThreadRef p);

PlankThreadID pl_Thread_GetID (PlankThreadRef p);

PlankResult pl_Thread_SetName (PlankThreadRef p, const char* name);

PlankResult pl_Thread_SetFunction (PlankThreadRef p, PlankThreadFunction function);

PlankResult pl_Thread_SetUserData (PlankThreadRef p, PlankP userData);

PlankP pl_Thread_GetUserData (PlankThreadRef p);

PlankResult pl_Thread_Start (PlankThreadRef p);

PlankResult pl_Thread_Cancel (PlankThreadRef p);

PlankResult pl_Thread_Wait (PlankThreadRef p);

PlankResult pl_Thread_Pause (PlankThreadRef p);
PlankResult pl_Thread_PauseWithTimeout (PlankThreadRef p, double duration);
PlankResult pl_Thread_Resume (PlankThreadRef p);


PlankB pl_Thread_IsRunning (PlankThreadRef p);

PlankResult pl_Thread_SetShouldExit (PlankThreadRef p);

PlankB pl_Thread_GetShouldExit (PlankThreadRef p);

PlankResult pl_Thread_SetPriority (PlankThreadRef p, int priority);
PlankResult pl_Thread_SetPriorityAudio (PlankThreadRef p, int blockSize, double sampleRate);
PlankResult pl_Thread_SetAffinity (PlankThreadRef p, int affinity);

PLANK_END_C_LINKAGE

#if !DOXYGEN
#if PLANK_APPLE || PLANK_LINUX
typedef pthread_t PlankThreadNativeHandle;
typedef void* PlankThreadNativeReturn;
#define PLANK_THREADCALL
#endif // PLANK_APPLE

#if PLANK_ANDROID
typedef pthread_t PlankThreadNativeHandle;
typedef void* PlankThreadNativeReturn;
#define PLANK_THREADCALL
#endif // PLANK_ANDROID

#if PLANK_WIN
typedef uintptr_t PlankThreadNativeHandle;
typedef unsigned PlankThreadNativeReturn;
#define PLANK_THREADCALL __stdcall
#endif // PLANK_WINDOWS

#define PLANK_THREAD_MAXNAMELENGTH 256

typedef struct PlankThread
{
    // could pack thread, shouldExitAtom and isRunningAtom into a PX
    PlankThreadNativeHandle thread;
    PlankThreadID threadID;
    PlankThreadFunction function;
    PLANK_ALIGN(PLANK_WIDESIZE) PlankAtomicPX userDataAtom;
    PLANK_ALIGN(4) PlankAtomicI shouldExitAtom;
    PLANK_ALIGN(4) PlankAtomicI isRunningAtom;
    PLANK_ALIGN(4) PlankAtomicI paused;
    char name[PLANK_THREAD_MAXNAMELENGTH];
    int priority;
    int affinity;
} PlankThread;
#endif


#endif // PLANK_THREAD_H