Beispiel #1
0
extern "C" int pthread_create (pthread_t *thread,
                               const pthread_attr_t *attr,
                               void * (*start_routine)(void *),
                               void * arg)
#if !defined(__SUNPRO_CC) && !defined(__APPLE__) && !defined(__FreeBSD__)
  throw ()
#endif
{
  // Force initialization of the TLAB before our first thread is created.
  static volatile TheCustomHeapType * t = initializeCustomHeap();
  t = t;

#if defined(__linux__) || defined(__APPLE__)
  char fname[] = "pthread_create";
#else
  char fname[] = "_pthread_create";
#endif

  // A pointer to the library version of pthread_create.
  static pthread_create_function real_pthread_create =
    reinterpret_cast<pthread_create_function>
    (reinterpret_cast<intptr_t>(dlsym(RTLD_NEXT, fname)));

  anyThreadCreated = true;

  pair<threadFunctionType, void *> * args =
    // new (_heap.malloc(sizeof(pair<threadFunctionType, void*>)))
    new
    pair<threadFunctionType, void *> (start_routine, arg);

  int result = (*real_pthread_create)(thread, attr, startMeUp, args);

  return result;
}
Beispiel #2
0
extern "C" int thr_create (void * stack_base,
                           size_t stack_size,
                           void * (*start_routine)(void *),
                           void * arg,
                           long flags,
                           thread_t * new_tid) {
  // Force initialization of the TLAB before our first thread is created.
  static volatile TheCustomHeapType * t = initializeCustomHeap();
  t = t;

  char fname[] = "_thr_create";

  // Instantiate the pointer to thr_create, if it hasn't been
  // instantiated yet.

  // A pointer to the library version of thr_create.
  static thr_create_function real_thr_create =
    (thr_create_function) dlsym (RTLD_NEXT, fname);

  anyThreadCreated = true;

  typedef pair<threadFunctionType, void *> argsType;
  argsType * args =
    new (getCustomHeap()->malloc(sizeof(argsType)))
    argsType (start_routine, arg);

  int result =
    (*real_thr_create)(stack_base, stack_size, startMeUp, args, flags, new_tid);

  return result;
}
Beispiel #3
0
TheCustomHeapType * getCustomHeap() {
  // The pointer to the TLAB itself.
  TheCustomHeapType * tlab = theTLAB;
  if (tlab == NULL) {
    tlab = theTLAB = initializeCustomHeap();
  }
  return tlab;
}
Beispiel #4
0
TheCustomHeapType * getCustomHeap() {
  TheCustomHeapType * heap;
  initTSD();
  heap = reinterpret_cast<TheCustomHeapType *>(pthread_getspecific(theHeapKey));
  if (heap == NULL) {
    heap = initializeCustomHeap();
  }
  return heap;
}
Beispiel #5
0
TheCustomHeapType * getCustomHeap() {
  // The pointer to the TLAB itself.
  auto tlab = theTLAB;
  if (tlab == nullptr) {
    tlab = initializeCustomHeap();
    theTLAB = tlab;
  }
  return tlab;
}
Beispiel #6
0
inline TheCustomHeapType * getCustomHeap (void) {
  TheCustomHeapType * heap;
#if defined(_WIN32)
  heap = (TheCustomHeapType *) TlsGetValue (LocalTLABIndex);
#else
  createKey();
  heap = (TheCustomHeapType *) pthread_getspecific (theHeapKey);
#endif
  if (heap == NULL)  {
    heap = initializeCustomHeap();
  }
  return heap;
}
Beispiel #7
0
// A special routine we call on thread exit to free up some resources.
static void exitRoutine() {
  TheCustomHeapType * heap = initializeCustomHeap();

  // Relinquish the assigned heap.
  getMainHoardHeap()->releaseHeap();

  // Clear the heap (via its destructor).
  heap->~TheCustomHeapType();

#if !defined(USE_THREAD_KEYWORD)
  // Reclaim the memory associated with the heap (thread-specific data).
  pthread_key_delete (theHeapKey);
#endif
}
Beispiel #8
0
  static inline void * startMeUp(void * a) {
    initializeCustomHeap();
    getMainHoardHeap()->findUnusedHeap();
    auto * z = (pair<threadFunctionType, void *> *) a;
    
    auto f   = z->first;
    auto arg = z->second;
    auto result = (*f)(arg);

    delete z;

    exitRoutine();

    return result;
  }
Beispiel #9
0
TheCustomHeapType * getCustomHeap() {
  // The pointer to the TLAB itself.
  theTLAB = (theTLAB ? theTLAB : initializeCustomHeap());
  return theTLAB;
}