auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/cpp/src/concurrency/PosixThreadFactory.cpp

@@ -1,314 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include "PosixThreadFactory.h"
-#include "Exception.h"
-
-#if GOOGLE_PERFTOOLS_REGISTER_THREAD
-#  include <google/profiler.h>
-#endif
-
-#include <assert.h>
-#include <pthread.h>
-
-#include <iostream>
-
-#include <boost/weak_ptr.hpp>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-using boost::shared_ptr;
-using boost::weak_ptr;
-
-/**
- * The POSIX thread class.
- *
- * @version $Id:$
- */
-class PthreadThread: public Thread {
- public:
-
-  enum STATE {
-    uninitialized,
-    starting,
-    started,
-    stopping,
-    stopped
-  };
-
-  static const int MB = 1024 * 1024;
-
-  static void* threadMain(void* arg);
-
- private:
-  pthread_t pthread_;
-  STATE state_;
-  int policy_;
-  int priority_;
-  int stackSize_;
-  weak_ptr<PthreadThread> self_;
-  bool detached_;
-
- public:
-
-  PthreadThread(int policy, int priority, int stackSize, bool detached, shared_ptr<Runnable> runnable) :
-    pthread_(0),
-    state_(uninitialized),
-    policy_(policy),
-    priority_(priority),
-    stackSize_(stackSize),
-    detached_(detached) {
-
-    this->Thread::runnable(runnable);
-  }
-
-  ~PthreadThread() {
-    /* Nothing references this thread, if is is not detached, do a join
-       now, otherwise the thread-id and, possibly, other resources will
-       be leaked. */
-    if(!detached_) {
-      try {
-        join();
-      } catch(...) {
-        // We're really hosed.
-      }
-    }
-  }
-
-  void start() {
-    if (state_ != uninitialized) {
-      return;
-    }
-
-    pthread_attr_t thread_attr;
-    if (pthread_attr_init(&thread_attr) != 0) {
-        throw SystemResourceException("pthread_attr_init failed");
-    }
-
-    if(pthread_attr_setdetachstate(&thread_attr,
-                                   detached_ ?
-                                   PTHREAD_CREATE_DETACHED :
-                                   PTHREAD_CREATE_JOINABLE) != 0) {
-        throw SystemResourceException("pthread_attr_setdetachstate failed");
-    }
-
-    // Set thread stack size
-    if (pthread_attr_setstacksize(&thread_attr, MB * stackSize_) != 0) {
-      throw SystemResourceException("pthread_attr_setstacksize failed");
-    }
-
-    // Set thread policy
-    if (pthread_attr_setschedpolicy(&thread_attr, policy_) != 0) {
-      throw SystemResourceException("pthread_attr_setschedpolicy failed");
-    }
-
-    struct sched_param sched_param;
-    sched_param.sched_priority = priority_;
-
-    // Set thread priority
-    if (pthread_attr_setschedparam(&thread_attr, &sched_param) != 0) {
-      throw SystemResourceException("pthread_attr_setschedparam failed");
-    }
-
-    // Create reference
-    shared_ptr<PthreadThread>* selfRef = new shared_ptr<PthreadThread>();
-    *selfRef = self_.lock();
-
-    state_ = starting;
-
-    if (pthread_create(&pthread_, &thread_attr, threadMain, (void*)selfRef) != 0) {
-      throw SystemResourceException("pthread_create failed");
-    }
-  }
-
-  void join() {
-    if (!detached_ && state_ != uninitialized) {
-      void* ignore;
-      /* XXX
-         If join fails it is most likely due to the fact
-         that the last reference was the thread itself and cannot
-         join.  This results in leaked threads and will eventually
-         cause the process to run out of thread resources.
-         We're beyond the point of throwing an exception.  Not clear how
-         best to handle this. */
-      detached_ = pthread_join(pthread_, &ignore) == 0;
-    }
-  }
-
-  Thread::id_t getId() {
-    return (Thread::id_t)pthread_;
-  }
-
-  shared_ptr<Runnable> runnable() const { return Thread::runnable(); }
-
-  void runnable(shared_ptr<Runnable> value) { Thread::runnable(value); }
-
-  void weakRef(shared_ptr<PthreadThread> self) {
-    assert(self.get() == this);
-    self_ = weak_ptr<PthreadThread>(self);
-  }
-};
-
-void* PthreadThread::threadMain(void* arg) {
-  shared_ptr<PthreadThread> thread = *(shared_ptr<PthreadThread>*)arg;
-  delete reinterpret_cast<shared_ptr<PthreadThread>*>(arg);
-
-  if (thread == NULL) {
-    return (void*)0;
-  }
-
-  if (thread->state_ != starting) {
-    return (void*)0;
-  }
-
-#if GOOGLE_PERFTOOLS_REGISTER_THREAD
-  ProfilerRegisterThread();
-#endif
-
-  thread->state_ = starting;
-  thread->runnable()->run();
-  if (thread->state_ != stopping && thread->state_ != stopped) {
-    thread->state_ = stopping;
-  }
-
-  return (void*)0;
-}
-
-/**
- * POSIX Thread factory implementation
- */
-class PosixThreadFactory::Impl {
-
- private:
-  POLICY policy_;
-  PRIORITY priority_;
-  int stackSize_;
-  bool detached_;
-
-  /**
-   * Converts generic posix thread schedule policy enums into pthread
-   * API values.
-   */
-  static int toPthreadPolicy(POLICY policy) {
-    switch (policy) {
-    case OTHER:
-      return SCHED_OTHER;
-    case FIFO:
-      return SCHED_FIFO;
-    case ROUND_ROBIN:
-      return SCHED_RR;
-    }
-    return SCHED_OTHER;
-  }
-
-  /**
-   * Converts relative thread priorities to absolute value based on posix
-   * thread scheduler policy
-   *
-   *  The idea is simply to divide up the priority range for the given policy
-   * into the correpsonding relative priority level (lowest..highest) and
-   * then pro-rate accordingly.
-   */
-  static int toPthreadPriority(POLICY policy, PRIORITY priority) {
-    int pthread_policy = toPthreadPolicy(policy);
-    int min_priority = 0;
-    int max_priority = 0;
-#ifdef HAVE_SCHED_GET_PRIORITY_MIN
-    min_priority = sched_get_priority_min(pthread_policy);
-#endif
-#ifdef HAVE_SCHED_GET_PRIORITY_MAX
-    max_priority = sched_get_priority_max(pthread_policy);
-#endif
-    int quanta = (HIGHEST - LOWEST) + 1;
-    float stepsperquanta = (max_priority - min_priority) / quanta;
-
-    if (priority <= HIGHEST) {
-      return (int)(min_priority + stepsperquanta * priority);
-    } else {
-      // should never get here for priority increments.
-      assert(false);
-      return (int)(min_priority + stepsperquanta * NORMAL);
-    }
-  }
-
- public:
-
-  Impl(POLICY policy, PRIORITY priority, int stackSize, bool detached) :
-    policy_(policy),
-    priority_(priority),
-    stackSize_(stackSize),
-    detached_(detached) {}
-
-  /**
-   * Creates a new POSIX thread to run the runnable object
-   *
-   * @param runnable A runnable object
-   */
-  shared_ptr<Thread> newThread(shared_ptr<Runnable> runnable) const {
-    shared_ptr<PthreadThread> result = shared_ptr<PthreadThread>(new PthreadThread(toPthreadPolicy(policy_), toPthreadPriority(policy_, priority_), stackSize_, detached_, runnable));
-    result->weakRef(result);
-    runnable->thread(result);
-    return result;
-  }
-
-  int getStackSize() const { return stackSize_; }
-
-  void setStackSize(int value) { stackSize_ = value; }
-
-  PRIORITY getPriority() const { return priority_; }
-
-  /**
-   * Sets priority.
-   *
-   *  XXX
-   *  Need to handle incremental priorities properly.
-   */
-  void setPriority(PRIORITY value) { priority_ = value; }
-
-  bool isDetached() const { return detached_; }
-
-  void setDetached(bool value) { detached_ = value; }
-
-  Thread::id_t getCurrentThreadId() const {
-    // TODO(dreiss): Stop using C-style casts.
-    return (id_t)pthread_self();
-  }
-
-};
-
-PosixThreadFactory::PosixThreadFactory(POLICY policy, PRIORITY priority, int stackSize, bool detached) :
-  impl_(new PosixThreadFactory::Impl(policy, priority, stackSize, detached)) {}
-
-shared_ptr<Thread> PosixThreadFactory::newThread(shared_ptr<Runnable> runnable) const { return impl_->newThread(runnable); }
-
-int PosixThreadFactory::getStackSize() const { return impl_->getStackSize(); }
-
-void PosixThreadFactory::setStackSize(int value) { impl_->setStackSize(value); }
-
-PosixThreadFactory::PRIORITY PosixThreadFactory::getPriority() const { return impl_->getPriority(); }
-
-void PosixThreadFactory::setPriority(PosixThreadFactory::PRIORITY value) { impl_->setPriority(value); }
-
-bool PosixThreadFactory::isDetached() const { return impl_->isDetached(); }
-
-void PosixThreadFactory::setDetached(bool value) { impl_->setDetached(value); }
-
-Thread::id_t PosixThreadFactory::getCurrentThreadId() const { return impl_->getCurrentThreadId(); }
-
-}}} // apache::thrift::concurrency

data/vendor/gems/thrift/lib/cpp/src/concurrency/PosixThreadFactory.h

@@ -1,130 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _THRIFT_CONCURRENCY_POSIXTHREADFACTORY_H_
-#define _THRIFT_CONCURRENCY_POSIXTHREADFACTORY_H_ 1
-
-#include "Thread.h"
-
-#include <boost/shared_ptr.hpp>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-/**
- * A thread factory to create posix threads
- *
- * @version $Id:$
- */
-class PosixThreadFactory : public ThreadFactory {
-
- public:
-
-  /**
-   * POSIX Thread scheduler policies
-   */
-  enum POLICY {
-    OTHER,
-    FIFO,
-    ROUND_ROBIN
-  };
-
-  /**
-   * POSIX Thread scheduler relative priorities,
-   *
-   * Absolute priority is determined by scheduler policy and OS. This
-   * enumeration specifies relative priorities such that one can specify a
-   * priority withing a giving scheduler policy without knowing the absolute
-   * value of the priority.
-   */
-  enum PRIORITY {
-    LOWEST = 0,
-    LOWER = 1,
-    LOW = 2,
-    NORMAL = 3,
-    HIGH = 4,
-    HIGHER = 5,
-    HIGHEST = 6,
-    INCREMENT = 7,
-    DECREMENT = 8
-  };
-
-  /**
-   * Posix thread (pthread) factory.  All threads created by a factory are reference-counted
-   * via boost::shared_ptr and boost::weak_ptr.  The factory guarantees that threads and
-   * the Runnable tasks they host will be properly cleaned up once the last strong reference
-   * to both is given up.
-   *
-   * Threads are created with the specified policy, priority, stack-size and detachable-mode
-   * detached means the thread is free-running and will release all system resources the
-   * when it completes.  A detachable thread is not joinable.  The join method
-   * of a detachable thread will return immediately with no error.
-   *
-   * By default threads are not joinable.
-   */
-
-  PosixThreadFactory(POLICY policy=ROUND_ROBIN, PRIORITY priority=NORMAL, int stackSize=1, bool detached=true);
-
-  // From ThreadFactory;
-  boost::shared_ptr<Thread> newThread(boost::shared_ptr<Runnable> runnable) const;
-
-  // From ThreadFactory;
-  Thread::id_t getCurrentThreadId() const;
-
-  /**
-   * Gets stack size for created threads
-   *
-   * @return int size in megabytes
-   */
-  virtual int getStackSize() const;
-
-  /**
-   * Sets stack size for created threads
-   *
-   * @param value size in megabytes
-   */
-  virtual void setStackSize(int value);
-
-  /**
-   * Gets priority relative to current policy
-   */
-  virtual PRIORITY getPriority() const;
-
-  /**
-   * Sets priority relative to current policy
-   */
-  virtual void setPriority(PRIORITY priority);
-
-  /**
-   * Sets detached mode of threads
-   */
-  virtual void setDetached(bool detached);
-
-  /**
-   * Gets current detached mode
-   */
-  virtual bool isDetached() const;
-
- private:
-  class Impl;
-  boost::shared_ptr<Impl> impl_;
-};
-
-}}} // apache::thrift::concurrency
-
-#endif // #ifndef _THRIFT_CONCURRENCY_POSIXTHREADFACTORY_H_

data/vendor/gems/thrift/lib/cpp/src/concurrency/Thread.h

@@ -1,125 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _THRIFT_CONCURRENCY_THREAD_H_
-#define _THRIFT_CONCURRENCY_THREAD_H_ 1
-
-#include <stdint.h>
-#include <boost/shared_ptr.hpp>
-#include <boost/weak_ptr.hpp>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-class Thread;
-
-/**
- * Minimal runnable class.  More or less analogous to java.lang.Runnable.
- *
- * @version $Id:$
- */
-class Runnable {
-
- public:
-  virtual ~Runnable() {};
-  virtual void run() = 0;
-
-  /**
-   * Gets the thread object that is hosting this runnable object  - can return
-   * an empty boost::shared pointer if no references remain on thet thread  object
-   */
-  virtual boost::shared_ptr<Thread> thread() { return thread_.lock(); }
-
-  /**
-   * Sets the thread that is executing this object.  This is only meant for
-   * use by concrete implementations of Thread.
-   */
-  virtual void thread(boost::shared_ptr<Thread> value) { thread_ = value; }
-
- private:
-  boost::weak_ptr<Thread> thread_;
-};
-
-/**
- * Minimal thread class. Returned by thread factory bound to a Runnable object
- * and ready to start execution.  More or less analogous to java.lang.Thread
- * (minus all the thread group, priority, mode and other baggage, since that
- * is difficult to abstract across platforms and is left for platform-specific
- * ThreadFactory implemtations to deal with
- *
- * @see apache::thrift::concurrency::ThreadFactory)
- */
-class Thread {
-
- public:
-
-  typedef uint64_t id_t;
-
-  virtual ~Thread() {};
-
-  /**
-   * Starts the thread. Does platform specific thread creation and
-   * configuration then invokes the run method of the Runnable object bound
-   * to this thread.
-   */
-  virtual void start() = 0;
-
-  /**
-   * Join this thread. Current thread blocks until this target thread
-   * completes.
-   */
-  virtual void join() = 0;
-
-  /**
-   * Gets the thread's platform-specific ID
-   */
-  virtual id_t getId() = 0;
-
-  /**
-   * Gets the runnable object this thread is hosting
-   */
-  virtual boost::shared_ptr<Runnable> runnable() const { return _runnable; }
-
- protected:
-  virtual void runnable(boost::shared_ptr<Runnable> value) { _runnable = value; }
-
- private:
-  boost::shared_ptr<Runnable> _runnable;
-
-};
-
-/**
- * Factory to create platform-specific thread object and bind them to Runnable
- * object for execution
- */
-class ThreadFactory {
-
- public:
-  virtual ~ThreadFactory() {}
-  virtual boost::shared_ptr<Thread> newThread(boost::shared_ptr<Runnable> runnable) const = 0;
-
-  /** Gets the current thread id or unknown_thread_id if the current thread is not a thrift thread */
-
-  static const Thread::id_t unknown_thread_id;
-
-  virtual Thread::id_t getCurrentThreadId() const = 0;
-};
-
-}}} // apache::thrift::concurrency
-
-#endif // #ifndef _THRIFT_CONCURRENCY_THREAD_H_