/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*

** Thread Private Data

**

** There is an aribitrary limit on the number of keys that will be allocated

** by the runtime. It's largish, so it is intended to be a sanity check, not

** an impediment.

**

** There is a counter, initialized to zero and incremented every time a

** client asks for a new key, that holds the high water mark for keys. All

** threads logically have the same high water mark and are permitted to

** ask for TPD up to that key value.

**

** The vector to hold the TPD are allocated when PR_SetThreadPrivate() is

** called. The size of the vector will be some value greater than or equal

** to the current high water mark. Each thread has its own TPD length and

** vector.

**

** Threads that get private data for keys they have not set (or perhaps

** don't even exist for that thread) get a NULL return. If the key is

** beyond the high water mark, an error will be returned.

*/

/*

** As of this time, BeOS has its own TPD implementation.  Integrating

** this standard one is a TODO for anyone with a bit of spare time on

** their hand.  For now, we just #ifdef out this whole file and use

** the routines in pr/src/btthreads/

*/

#include "primpl.h"

#include <string.h>

#if defined(WIN95)

/*

** Some local variables report warnings on Win95 because the code paths

** using them are conditioned on HAVE_CUSTOME_USER_THREADS.

** The pragma suppresses the warning.

**

*/

#  pragma warning(disable : 4101)

#endif

#define _PR_TPD_LIMIT 128             /* arbitary limit on the TPD slots */

static PRInt32 _pr_tpd_length = 0;    /* current length of destructor vector */

static PRInt32 _pr_tpd_highwater = 0; /* next TPD key to be assigned */

static PRThreadPrivateDTOR* _pr_tpd_destructors = NULL;

/* the destructors are associated with

    the keys, therefore asserting that

    the TPD key depicts the data's 'type' */

/*

** Initialize the thread private data manipulation

*/

void _PR_InitTPD(void) {

  _pr_tpd_destructors = (PRThreadPrivateDTOR*)PR_CALLOC(

      _PR_TPD_LIMIT * sizeof(PRThreadPrivateDTOR*));

  PR_ASSERT(NULL != _pr_tpd_destructors);

  _pr_tpd_length = _PR_TPD_LIMIT;

}

/*

** Clean up the thread private data manipulation

*/

void _PR_CleanupTPD(void) {} /* _PR_CleanupTPD */

/*

** This routine returns a new index for per-thread-private data table.

** The index is visible to all threads within a process. This index can

** be used with the PR_SetThreadPrivate() and PR_GetThreadPrivate() routines

** to save and retrieve data associated with the index for a thread.

**

** The index independently maintains specific values for each binding thread.

** A thread can only get access to its own thread-specific-data.

**

** Upon a new index return the value associated with the index for all threads

** is NULL, and upon thread creation the value associated with all indices for

** that thread is NULL.

**

**     "dtor" is the destructor function to invoke when the private

**       data is set or destroyed

**

** Returns PR_FAILURE if the total number of indices will exceed the maximun

** allowed.

*/

PR_IMPLEMENT(PRStatus)

PR_NewThreadPrivateIndex(PRUintn* newIndex, PRThreadPrivateDTOR dtor) {

  PRStatus rv;

  PRInt32 index;

  if (!_pr_initialized) {

    _PR_ImplicitInitialization();

  }

  PR_ASSERT(NULL != newIndex);

  PR_ASSERT(NULL != _pr_tpd_destructors);

  index = PR_ATOMIC_INCREMENT(&_pr_tpd_highwater) - 1; /* allocate index */

  if (_PR_TPD_LIMIT <= index) {

    PR_SetError(PR_TPD_RANGE_ERROR, 0);

    rv = PR_FAILURE; /* that's just wrong */

  } else {

    _pr_tpd_destructors[index] = dtor; /* record destructor @index */

    *newIndex = (PRUintn)index;        /* copy into client's location */

    rv = PR_SUCCESS;                   /* that's okay */

  }

  return rv;

}

/*

** Define some per-thread-private data.

**     "index" is an index into the per-thread private data table

**     "priv" is the per-thread-private data

**

** If the per-thread private data table has a previously registered

** destructor function and a non-NULL per-thread-private data value,

** the destructor function is invoked.

**

** This can return PR_FAILURE if index is invalid (ie., beyond the limit

** on the TPD slots) or memory is insufficient to allocate an expanded

** vector.

*/

PR_IMPLEMENT(PRStatus) PR_SetThreadPrivate(PRUintn index, void* priv) {

  PRThread* self = PR_GetCurrentThread();

  /*

  ** To improve performance, we don't check if the index has been

  ** allocated.

  */

  if (index >= _PR_TPD_LIMIT) {

    PR_SetError(PR_TPD_RANGE_ERROR, 0);

    return PR_FAILURE;

  }

  PR_ASSERT(((NULL == self->privateData) && (0 == self->tpdLength)) ||

            ((NULL != self->privateData) && (0 != self->tpdLength)));

  /*

  ** If this thread does not have a sufficient vector for the index

  ** being set, go ahead and extend this vector now.

  */

  if ((NULL == self->privateData) || (self->tpdLength <= index)) {

    void* extension = PR_CALLOC(_pr_tpd_length * sizeof(void*));

    if (NULL == extension) {

      PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);

      return PR_FAILURE;

    }

    if (self->privateData) {

      (void)memcpy(extension, self->privateData,

                   self->tpdLength * sizeof(void*));

      PR_DELETE(self->privateData);

    }

    self->tpdLength = _pr_tpd_length;

    self->privateData = (void**)extension;

  }

  /*

  ** There wasn't much chance of having to call the destructor

  ** unless the slot already existed.

  */

  else if (self->privateData[index] && _pr_tpd_destructors[index]) {

    void* data = self->privateData[index];

    self->privateData[index] = NULL;

    (*_pr_tpd_destructors[index])(data);

  }

  PR_ASSERT(index < self->tpdLength);

  self->privateData[index] = priv;

  return PR_SUCCESS;

}

/*

** Recover the per-thread-private data for the current thread. "index" is

** the index into the per-thread private data table.

**

** The returned value may be NULL which is indistinguishable from an error

** condition.

**

*/

PR_IMPLEMENT(void*) PR_GetThreadPrivate(PRUintn index) {

  PRThread* self = PR_GetCurrentThread();

  void* tpd = ((NULL == self->privateData) || (index >= self->tpdLength))

                  ? NULL

                  : self->privateData[index];

  return tpd;

}

/*

** Destroy the thread's private data, if any exists. This is called at

** thread termination time only. There should be no threading issues

** since this is being called by the thread itself.

*/

void _PR_DestroyThreadPrivate(PRThread* self) {

#define _PR_TPD_DESTRUCTOR_ITERATIONS 4

  if (NULL != self->privateData) /* we have some */

  {

    PRBool clean;

    PRUint32 index;

    PRInt32 passes = _PR_TPD_DESTRUCTOR_ITERATIONS;

    PR_ASSERT(0 != self->tpdLength);

    do {

      clean = PR_TRUE;

      for (index = 0; index < self->tpdLength; ++index) {

        void* priv = self->privateData[index]; /* extract */

        if (NULL != priv)                      /* we have data at this index */

        {

          if (NULL != _pr_tpd_destructors[index]) {

            self->privateData[index] = NULL;     /* precondition */

            (*_pr_tpd_destructors[index])(priv); /* destroy */

            clean = PR_FALSE;                    /* unknown side effects */

          }

        }

      }

    } while ((--passes > 0) && !clean); /* limit # of passes */

    /*

    ** We give up after a fixed number of passes. Any non-NULL

    ** thread-private data value with a registered destructor

    ** function is not destroyed.

    */

    memset(self->privateData, 0, self->tpdLength * sizeof(void*));

  }

} /* _PR_DestroyThreadPrivate */