ThreadStart.h

/*
 * PROGRAM: JRD access method
 * MODULE: thd.h
 * DESCRIPTION: Thread support definitions
 *
 * The contents of this file are subject to the Interbase Public
 * License Version 1.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy
 * of the License at http://www.Inprise.com/IPL.html
 *
 * Software distributed under the License is distributed on an
 * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code was created by Inprise Corporation
 * and its predecessors. Portions created by Inprise Corporation are
 * Copyright (C) Inprise Corporation.
 *
 * All Rights Reserved.
 * Contributor(s): ______________________________________.
 *
 * 2002.10.28 Sean Leyne - Completed removal of obsolete "DGUX" port
 *
 * 2002.10.29 Sean Leyne - Removed obsolete "Netware" port
 *
 * Alex Peshkov
*/

#ifndef JRD_THREADSTART_H
#defineJRD_THREADSTART_H

#include"../common/ThreadData.h"
#include"../common/classes/semaphore.h"

#ifdef WIN_NT
#include<windows.h>
#endif


// Thread priorities (may be ignored)

constint THREAD_high = 1;
constint THREAD_medium_high = 2;
constint THREAD_medium = 3;
constint THREAD_medium_low = 4;
constint THREAD_low = 5;
constint THREAD_critical = 6;


// Thread startup

// BRS 01/07/2004
// Hack due to a bug in mingw.
// The definition inside the thdd class should be replaced with the following one.
typedef THREAD_ENTRY_DECLARE ThreadEntryPoint(THREAD_ENTRY_PARAM);

#if defined(WIN_NT)
typedef DWORD ThreadId;
#elif defined(LINUX) && !defined(ANDROID) && !defined(LSB_BUILD)
#defineUSE_LWP_AS_THREAD_ID
typedefint ThreadId;
#elif defined(USE_POSIX_THREADS)
typedefpthread_t ThreadId;
#else
error - unknown ThreadId type
#endif

classThread
{
public:
#ifdef WIN_NT
typedef DWORD InternalId;
typedef HANDLE Handle;
#endif
#ifdef USE_POSIX_THREADS
typedefpthread_tHandle;
typedefpthread_t InternalId;
#endif

static Thread start(ThreadEntryPoint* routine, void* arg, int priority_arg, Handle* p_handle = NULL);
staticvoidwaitForCompletion(Handle& handle);
staticvoidkill(Handle& handle);

static ThreadId getId();
static ThreadId getIdFromHandle(Handle threadHandle);

staticvoidsleep(unsigned milliseconds);
staticvoidyield();

staticboolisCurrent(InternalId iid);
boolisCurrent();

Thread()
 {
memset(&internalId, 0, sizeof(internalId));
 }

private:
Thread(InternalId iid)
 : internalId(iid)
 { }

 InternalId internalId;
};

inline ThreadId getThreadId()
{
returnThread::getId();
}


template <typename TA, void (*cleanup) (TA) = nullptr>
classThreadFinishSync
{
public:
typedefvoidThreadRoutine(TA);

ThreadFinishSync(Firebird::MemoryPool& pool, ThreadRoutine* routine, int priority_arg = THREAD_medium)
 : threadHandle(0),
threadRoutine(routine),
 threadPriority(priority_arg),
 closing(false)
 { }

voidrun(TA arg)
 {
 threadArg = arg;
Thread::start(internalRun, this, threadPriority, &threadHandle);
 }

booltryWait()
 {
if (closing)
 {
waitForCompletion();
returntrue;
 }
returnfalse;
 }

voidwaitForCompletion()
 {
if (threadHandle)
 {
Thread::waitForCompletion(threadHandle);
 threadHandle = 0;
 }
 }

private:
 Thread::Handle threadHandle;
 TA threadArg;
 ThreadRoutine* threadRoutine;
int threadPriority;
bool closing;

static THREAD_ENTRY_DECLARE internalRun(THREAD_ENTRY_PARAM arg)
 {
 ((ThreadFinishSync*) arg)->internalRun();
return0;
 }

voidinternalRun()
 {
try
 {
threadRoutine(threadArg);
 }
catch (const Firebird::Exception& ex)
 {
 threadArg->exceptionHandler(ex, threadRoutine);
 }

if (cleanup)
cleanup(threadArg);
 closing = true;
 }
};

#endif // JRD_THREADSTART_H