/* 

 * tclThread.c --

 *

 *	This file implements   Platform independent thread operations.

 *	Most of the real work is done in the platform dependent files.

 *

 * Copyright (c) 1998 by Sun Microsystems, Inc.

 * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.  

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tclThread.c,v 1.6.2.1 2004/05/06 01:02:59 davygrvy Exp $

 */

#include "tclInt.h"

#if defined(__SYMBIAN32__) 

#include "tclSymbianGlobals.h"

#endif 

/*

 * There are three classes of synchronization objects:

 * mutexes, thread data keys, and condition variables.

 * The following are used to record the memory used for these

 * objects so they can be finalized.

 *

 * These statics are guarded by the mutex in the caller of

 * TclRememberThreadData, e.g., TclpThreadDataKeyInit

 */

#ifndef __SYMBIAN32__ 

typedef struct {

    int num;		/* Number of objects remembered */

    int max;		/* Max size of the array */

    char **list;	/* List of pointers */

} SyncObjRecord;

#endif

#if !defined(__SYMBIAN32__) || !defined(__WINSCW__)

static SyncObjRecord keyRecord = {0, 0, NULL};

#endif

static SyncObjRecord mutexRecord = {0, 0, NULL};

static SyncObjRecord condRecord = {0, 0, NULL};

/*

 * Prototypes of functions used only in this file

 */

static void		RememberSyncObject _ANSI_ARGS_((char *objPtr,

			    SyncObjRecord *recPtr));

static void		ForgetSyncObject _ANSI_ARGS_((char *objPtr,

			    SyncObjRecord *recPtr));

/* 

 * Several functions are #defined to nothing in tcl.h if TCL_THREADS is not

 * specified.  Here we undo that so the procedures are defined in the

 * stubs table.

 */

#ifndef TCL_THREADS

#undef Tcl_MutexLock

#undef Tcl_MutexUnlock

#undef Tcl_MutexFinalize

#undef Tcl_ConditionNotify

#undef Tcl_ConditionWait

#undef Tcl_ConditionFinalize

#endif

/*

 *----------------------------------------------------------------------

 *

 * Tcl_GetThreadData --

 *

 *	This procedure allocates and initializes a chunk of thread

 *	local storage.

 *

 * Results:

 *	A thread-specific pointer to the data structure.

 *

 * Side effects:

 *	Will allocate memory the first time this thread calls for

 *	this chunk of storage.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C VOID *

Tcl_GetThreadData(keyPtr, size)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk */

    int size;			/* Size of storage block */

{

    VOID *result;

#ifdef TCL_THREADS

    /*

     * See if this is the first thread to init this key.

     */

    if (*keyPtr == NULL) {

	TclpThreadDataKeyInit(keyPtr);

    }

    /*

     * Initialize the key for this thread.

     */

    result = TclpThreadDataKeyGet(keyPtr);

    if (result == NULL) {

	result  = (VOID *)ckalloc((size_t)size);

	memset(result, 0, (size_t)size);

	TclpThreadDataKeySet(keyPtr, result);

    }

#else

    if (*keyPtr == NULL) {

	result = (VOID *)ckalloc((size_t)size);

	memset((char *)result, 0, (size_t)size);

	*keyPtr = (Tcl_ThreadDataKey)result;

	TclRememberDataKey(keyPtr);

    }

    result = *(VOID **)keyPtr;

#endif

    return result;

}

/*

 *----------------------------------------------------------------------

 *

 * TclThreadDataKeyGet --

 *

 *	This procedure returns a pointer to a block of thread local storage.

 *

 * Results:

 *	A thread-specific pointer to the data structure, or NULL

 *	if the memory has not been assigned to this key for this thread.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

VOID *

TclThreadDataKeyGet(keyPtr)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

{

#ifdef TCL_THREADS

    return (VOID *)TclpThreadDataKeyGet(keyPtr);

#else

    char *result = *(char **)keyPtr;

    return (VOID *)result;

#endif /* TCL_THREADS */

}

/*

 *----------------------------------------------------------------------

 *

 * TclThreadDataKeySet --

 *

 *	This procedure sets a thread local storage pointer.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	The assigned value will be returned by TclpThreadDataKeyGet.

 *

 *----------------------------------------------------------------------

 */

void

TclThreadDataKeySet(keyPtr, data)

    Tcl_ThreadDataKey *keyPtr;	/* Identifier for the data chunk,

				 * really (pthread_key_t **) */

    VOID *data;			/* Thread local storage */

{

#ifdef TCL_THREADS

    if (*keyPtr == NULL) {

	TclpThreadDataKeyInit(keyPtr);

    }

    TclpThreadDataKeySet(keyPtr, data);

#else

    *keyPtr = (Tcl_ThreadDataKey)data;

#endif /* TCL_THREADS */

}

/*

 *----------------------------------------------------------------------

 *

 * RememberSyncObject

 *

 *      Keep a list of (mutexes/condition variable/data key)

 *	used during finalization.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Add to the appropriate list.

 *

 *----------------------------------------------------------------------

 */

static void

RememberSyncObject(objPtr, recPtr)

    char *objPtr;		/* Pointer to sync object */

    SyncObjRecord *recPtr;	/* Record of sync objects */

{

    char **newList;

    int i, j;

    /*

     * Save the pointer to the allocated object so it can be finalized.

     * Grow the list of pointers if necessary, copying only non-NULL

     * pointers to the new list.

     */

    if (recPtr->num >= recPtr->max) {

	recPtr->max += 8;

	newList = (char **)ckalloc(recPtr->max * sizeof(char *));

	for (i=0,j=0 ; i<recPtr->num ; i++) {

            if (recPtr->list[i] != NULL) {

		newList[j++] = recPtr->list[i];

            }

	}

	if (recPtr->list != NULL) {

	    ckfree((char *)recPtr->list);

	}

	recPtr->list = newList;

	recPtr->num = j;

    }

    recPtr->list[recPtr->num] = objPtr;

    recPtr->num++;

}

/*

 *----------------------------------------------------------------------

 *

 * ForgetSyncObject

 *

 *      Remove a single object from the list.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Remove from the appropriate list.

 *

 *----------------------------------------------------------------------

 */

static void

ForgetSyncObject(objPtr, recPtr)

    char *objPtr;		/* Pointer to sync object */

    SyncObjRecord *recPtr;	/* Record of sync objects */

{

    int i;

    for (i=0 ; i<recPtr->num ; i++) {

	if (objPtr == recPtr->list[i]) {

	    recPtr->list[i] = NULL;

	    return;

	}

    }

}

/*

 *----------------------------------------------------------------------

 *

 * TclRememberMutex

 *

 *      Keep a list of mutexes used during finalization.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Add to the mutex list.

 *

 *----------------------------------------------------------------------

 */

void

TclRememberMutex(mutexPtr)

    Tcl_Mutex *mutexPtr;

{

    RememberSyncObject((char *)mutexPtr, &mutexRecord);

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_MutexFinalize

 *

 *      Finalize a single mutex and remove it from the

 *	list of remembered objects.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Remove the mutex from the list.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_MutexFinalize(mutexPtr)

    Tcl_Mutex *mutexPtr;

{

#ifdef TCL_THREADS

    TclpFinalizeMutex(mutexPtr);

#endif

    ForgetSyncObject((char *)mutexPtr, &mutexRecord);

}

/*

 *----------------------------------------------------------------------

 *

 * TclRememberDataKey

 *

 *      Keep a list of thread data keys used during finalization.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Add to the key list.

 *

 *----------------------------------------------------------------------

 */

void

TclRememberDataKey(keyPtr)

    Tcl_ThreadDataKey *keyPtr;

{

    RememberSyncObject((char *)keyPtr, &keyRecord);

}

/*

 *----------------------------------------------------------------------

 *

 * TclRememberCondition

 *

 *      Keep a list of condition variables used during finalization.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Add to the condition variable list.

 *

 *----------------------------------------------------------------------

 */

void

TclRememberCondition(condPtr)

    Tcl_Condition *condPtr;

{

    RememberSyncObject((char *)condPtr, &condRecord);

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ConditionFinalize

 *

 *      Finalize a single condition variable and remove it from the

 *	list of remembered objects.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Remove the condition variable from the list.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_ConditionFinalize(condPtr)

    Tcl_Condition *condPtr;

{

#ifdef TCL_THREADS

    TclpFinalizeCondition(condPtr);

#endif

    ForgetSyncObject((char *)condPtr, &condRecord);

}

/*

 *----------------------------------------------------------------------

 *

 * TclFinalizeThreadData --

 *

 *	This procedure cleans up the thread-local storage.  This is

 *	called once for each thread.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Frees up all thread local storage.

 *

 *----------------------------------------------------------------------

 */

void

TclFinalizeThreadData()

{

    int i;

    Tcl_ThreadDataKey *keyPtr;

    TclpMasterLock();

    for (i=0 ; i<keyRecord.num ; i++) {

	keyPtr = (Tcl_ThreadDataKey *) keyRecord.list[i];

#ifdef TCL_THREADS

	TclpFinalizeThreadData(keyPtr);

#else

	if (*keyPtr != NULL) {

	    ckfree((char *)*keyPtr);

	    *keyPtr = NULL;

	}

#endif

    }

    TclpMasterUnlock();

}

/*

 *----------------------------------------------------------------------

 *

 * TclFinalizeSynchronization --

 *

 *      This procedure cleans up all synchronization objects:

 *      mutexes, condition variables, and thread-local storage.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Frees up the memory.

 *

 *----------------------------------------------------------------------

 */

void

TclFinalizeSynchronization()

{

#ifdef TCL_THREADS

    Tcl_ThreadDataKey *keyPtr;

    Tcl_Mutex *mutexPtr;

    Tcl_Condition *condPtr;

    int i;

    TclpMasterLock();

    for (i=0 ; i<keyRecord.num ; i++) {

	keyPtr = (Tcl_ThreadDataKey *)keyRecord.list[i];

	TclpFinalizeThreadDataKey(keyPtr);

    }

    if (keyRecord.list != NULL) {

	ckfree((char *)keyRecord.list);

	keyRecord.list = NULL;

    }

    keyRecord.max = 0;

    keyRecord.num = 0;

    for (i=0 ; i<mutexRecord.num ; i++) {

	mutexPtr = (Tcl_Mutex *)mutexRecord.list[i];

	if (mutexPtr != NULL) {

	    TclpFinalizeMutex(mutexPtr);

	}

    }

    if (mutexRecord.list != NULL) {

	ckfree((char *)mutexRecord.list);

	mutexRecord.list = NULL;

    }

    mutexRecord.max = 0;

    mutexRecord.num = 0;

    for (i=0 ; i<condRecord.num ; i++) {

	condPtr = (Tcl_Condition *)condRecord.list[i];

	if (condPtr != NULL) {

	    TclpFinalizeCondition(condPtr);

	}

    }

    if (condRecord.list != NULL) {

	ckfree((char *)condRecord.list);

	condRecord.list = NULL;

    }

    condRecord.max = 0;

    condRecord.num = 0;

    TclpMasterUnlock();

#else

    if (keyRecord.list != NULL) {

	ckfree((char *)keyRecord.list);

	keyRecord.list = NULL;

    }

    keyRecord.max = 0;

    keyRecord.num = 0;

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ExitThread --

 *

 *	This procedure is called to terminate the current thread.

 *	This should be used by extensions that create threads with

 *	additional interpreters in them.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	All thread exit handlers are invoked, then the thread dies.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_ExitThread(status)

    int status;

{

    Tcl_FinalizeThread();

#ifdef TCL_THREADS

    TclpThreadExit(status);

#endif

}

#ifndef TCL_THREADS

/*

 *----------------------------------------------------------------------

 *

 * Tcl_ConditionWait, et al. --

 *

 *	These noop procedures are provided so the stub table does

 *	not have to be conditionalized for threads.  The real

 *	implementations of these functions live in the platform

 *	specific files.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

#undef Tcl_ConditionWait

EXPORT_C void

Tcl_ConditionWait(condPtr, mutexPtr, timePtr)

    Tcl_Condition *condPtr;	/* Really (pthread_cond_t **) */

    Tcl_Mutex *mutexPtr;	/* Really (pthread_mutex_t **) */

    Tcl_Time *timePtr;		/* Timeout on waiting period */

{

}

#undef Tcl_ConditionNotify

EXPORT_C void

Tcl_ConditionNotify(condPtr)

    Tcl_Condition *condPtr;

{

}

#undef Tcl_MutexLock

EXPORT_C void

Tcl_MutexLock(mutexPtr)

    Tcl_Mutex *mutexPtr;

{

}

#undef Tcl_MutexUnlock

EXPORT_C void

Tcl_MutexUnlock(mutexPtr)

    Tcl_Mutex *mutexPtr;

{

}

#endif