auser-poolparty 1.3.1 → 1.3.2

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

@@ -1,284 +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 "TimerManager.h"
-#include "Exception.h"
-#include "Util.h"
-
-#include <assert.h>
-#include <iostream>
-#include <set>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-using boost::shared_ptr;
-
-/**
- * TimerManager class
- *
- * @version $Id:$
- */
-class TimerManager::Task : public Runnable {
-
- public:
-  enum STATE {
-    WAITING,
-    EXECUTING,
-    CANCELLED,
-    COMPLETE
-  };
-
-  Task(shared_ptr<Runnable> runnable) :
-    runnable_(runnable),
-    state_(WAITING) {}
-
-  ~Task() {
-  }
-
-  void run() {
-    if (state_ == EXECUTING) {
-      runnable_->run();
-      state_ = COMPLETE;
-    }
-  }
-
- private:
-  shared_ptr<Runnable> runnable_;
-  class TimerManager::Dispatcher;
-  friend class TimerManager::Dispatcher;
-  STATE state_;
-};
-
-class TimerManager::Dispatcher: public Runnable {
-
- public:
-  Dispatcher(TimerManager* manager) :
-    manager_(manager) {}
-
-  ~Dispatcher() {}
-
-  /**
-   * Dispatcher entry point
-   *
-   * As long as dispatcher thread is running, pull tasks off the task taskMap_
-   * and execute.
-   */
-  void run() {
-    {
-      Synchronized s(manager_->monitor_);
-      if (manager_->state_ == TimerManager::STARTING) {
-        manager_->state_ = TimerManager::STARTED;
-        manager_->monitor_.notifyAll();
-      }
-    }
-
-    do {
-      std::set<shared_ptr<TimerManager::Task> > expiredTasks;
-      {
-        Synchronized s(manager_->monitor_);
-        task_iterator expiredTaskEnd;
-        int64_t now = Util::currentTime();
-        while (manager_->state_ == TimerManager::STARTED &&
-               (expiredTaskEnd = manager_->taskMap_.upper_bound(now)) == manager_->taskMap_.begin()) {
-          int64_t timeout = 0LL;
-          if (!manager_->taskMap_.empty()) {
-            timeout = manager_->taskMap_.begin()->first - now;
-          }
-          assert((timeout != 0 && manager_->taskCount_ > 0) || (timeout == 0 && manager_->taskCount_ == 0));
-          try {
-            manager_->monitor_.wait(timeout);
-          } catch (TimedOutException &e) {}
-          now = Util::currentTime();
-        }
-
-        if (manager_->state_ == TimerManager::STARTED) {
-          for (task_iterator ix = manager_->taskMap_.begin(); ix != expiredTaskEnd; ix++) {
-            shared_ptr<TimerManager::Task> task = ix->second;
-            expiredTasks.insert(task);
-            if (task->state_ == TimerManager::Task::WAITING) {
-              task->state_ = TimerManager::Task::EXECUTING;
-            }
-            manager_->taskCount_--;
-          }
-          manager_->taskMap_.erase(manager_->taskMap_.begin(), expiredTaskEnd);
-        }
-      }
-
-      for (std::set<shared_ptr<Task> >::iterator ix =  expiredTasks.begin(); ix != expiredTasks.end(); ix++) {
-        (*ix)->run();
-      }
-
-    } while (manager_->state_ == TimerManager::STARTED);
-
-    {
-      Synchronized s(manager_->monitor_);
-      if (manager_->state_ == TimerManager::STOPPING) {
-        manager_->state_ = TimerManager::STOPPED;
-        manager_->monitor_.notify();
-      }
-    }
-    return;
-  }
-
- private:
-  TimerManager* manager_;
-  friend class TimerManager;
-};
-
-TimerManager::TimerManager() :
-  taskCount_(0),
-  state_(TimerManager::UNINITIALIZED),
-  dispatcher_(shared_ptr<Dispatcher>(new Dispatcher(this))) {
-}
-
-
-TimerManager::~TimerManager() {
-
-  // If we haven't been explicitly stopped, do so now.  We don't need to grab
-  // the monitor here, since stop already takes care of reentrancy.
-
-  if (state_ != STOPPED) {
-    try {
-      stop();
-    } catch(...) {
-      throw;
-      // uhoh
-    }
-  }
-}
-
-void TimerManager::start() {
-  bool doStart = false;
-  {
-    Synchronized s(monitor_);
-    if (threadFactory_ == NULL) {
-      throw InvalidArgumentException();
-    }
-    if (state_ == TimerManager::UNINITIALIZED) {
-      state_ = TimerManager::STARTING;
-      doStart = true;
-    }
-  }
-
-  if (doStart) {
-    dispatcherThread_ = threadFactory_->newThread(dispatcher_);
-    dispatcherThread_->start();
-  }
-
-  {
-    Synchronized s(monitor_);
-    while (state_ == TimerManager::STARTING) {
-      monitor_.wait();
-    }
-    assert(state_ != TimerManager::STARTING);
-  }
-}
-
-void TimerManager::stop() {
-  bool doStop = false;
-  {
-    Synchronized s(monitor_);
-    if (state_ == TimerManager::UNINITIALIZED) {
-      state_ = TimerManager::STOPPED;
-    } else if (state_ != STOPPING &&  state_ != STOPPED) {
-      doStop = true;
-      state_ = STOPPING;
-      monitor_.notifyAll();
-    }
-    while (state_ != STOPPED) {
-      monitor_.wait();
-    }
-  }
-
-  if (doStop) {
-    // Clean up any outstanding tasks
-    taskMap_.clear();
-
-    // Remove dispatcher's reference to us.
-    dispatcher_->manager_ = NULL;
-  }
-}
-
-shared_ptr<const ThreadFactory> TimerManager::threadFactory() const {
-  Synchronized s(monitor_);
-  return threadFactory_;
-}
-
-void TimerManager::threadFactory(shared_ptr<const ThreadFactory>  value) {
-  Synchronized s(monitor_);
-  threadFactory_ = value;
-}
-
-size_t TimerManager::taskCount() const {
-  return taskCount_;
-}
-
-void TimerManager::add(shared_ptr<Runnable> task, int64_t timeout) {
-  int64_t now = Util::currentTime();
-  timeout += now;
-
-  {
-    Synchronized s(monitor_);
-    if (state_ != TimerManager::STARTED) {
-      throw IllegalStateException();
-    }
-
-    // If the task map is empty, we will kick the dispatcher for sure. Otherwise, we kick him
-    // if the expiration time is shorter than the current value. Need to test before we insert,
-    // because the new task might insert at the front.
-    bool notifyRequired = (taskCount_ == 0) ? true : timeout < taskMap_.begin()->first;
-
-    taskCount_++;
-    taskMap_.insert(std::pair<int64_t, shared_ptr<Task> >(timeout, shared_ptr<Task>(new Task(task))));
-
-    // If the task map was empty, or if we have an expiration that is earlier
-    // than any previously seen, kick the dispatcher so it can update its
-    // timeout
-    if (notifyRequired) {
-      monitor_.notify();
-    }
-  }
-}
-
-void TimerManager::add(shared_ptr<Runnable> task, const struct timespec& value) {
-
-  int64_t expiration;
-  Util::toMilliseconds(expiration, value);
-
-  int64_t now = Util::currentTime();
-
-  if (expiration < now) {
-    throw  InvalidArgumentException();
-  }
-
-  add(task, expiration - now);
-}
-
-
-void TimerManager::remove(shared_ptr<Runnable> task) {
-  Synchronized s(monitor_);
-  if (state_ != TimerManager::STARTED) {
-    throw IllegalStateException();
-  }
-}
-
-const TimerManager::STATE TimerManager::state() const { return state_; }
-
-}}} // apache::thrift::concurrency
-

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

@@ -1,122 +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_TIMERMANAGER_H_
-#define _THRIFT_CONCURRENCY_TIMERMANAGER_H_ 1
-
-#include "Exception.h"
-#include "Monitor.h"
-#include "Thread.h"
-
-#include <boost/shared_ptr.hpp>
-#include <map>
-#include <time.h>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-/**
- * Timer Manager
- *
- * This class dispatches timer tasks when they fall due.
- *
- * @version $Id:$
- */
-class TimerManager {
-
- public:
-
-  TimerManager();
-
-  virtual ~TimerManager();
-
-  virtual boost::shared_ptr<const ThreadFactory> threadFactory() const;
-
-  virtual void threadFactory(boost::shared_ptr<const ThreadFactory> value);
-
-  /**
-   * Starts the timer manager service
-   *
-   * @throws IllegalArgumentException Missing thread factory attribute
-   */
-  virtual void start();
-
-  /**
-   * Stops the timer manager service
-   */
-  virtual void stop();
-
-  virtual size_t taskCount() const ;
-
-  /**
-   * Adds a task to be executed at some time in the future by a worker thread.
-   *
-   * @param task The task to execute
-   * @param timeout Time in milliseconds to delay before executing task
-   */
-  virtual void add(boost::shared_ptr<Runnable> task, int64_t timeout);
-
-  /**
-   * Adds a task to be executed at some time in the future by a worker thread.
-   *
-   * @param task The task to execute
-   * @param timeout Absolute time in the future to execute task.
-   */
-  virtual void add(boost::shared_ptr<Runnable> task, const struct timespec& timeout);
-
-  /**
-   * Removes a pending task
-   *
-   * @throws NoSuchTaskException Specified task doesn't exist. It was either
-   *                             processed already or this call was made for a
-   *                             task that was never added to this timer
-   *
-   * @throws UncancellableTaskException Specified task is already being
-   *                                    executed or has completed execution.
-   */
-  virtual void remove(boost::shared_ptr<Runnable> task);
-
-  enum STATE {
-    UNINITIALIZED,
-    STARTING,
-    STARTED,
-    STOPPING,
-    STOPPED
-  };
-
-  virtual const STATE state() const;
-
- private:
-  boost::shared_ptr<const ThreadFactory> threadFactory_;
-  class Task;
-  friend class Task;
-  std::multimap<int64_t, boost::shared_ptr<Task> > taskMap_;
-  size_t taskCount_;
-  Monitor monitor_;
-  STATE state_;
-  class Dispatcher;
-  friend class Dispatcher;
-  boost::shared_ptr<Dispatcher> dispatcher_;
-  boost::shared_ptr<Thread> dispatcherThread_;
-  typedef std::multimap<int64_t, boost::shared_ptr<TimerManager::Task> >::iterator task_iterator;
-  typedef std::pair<task_iterator, task_iterator> task_range;
-};
-
-}}} // apache::thrift::concurrency
-
-#endif // #ifndef _THRIFT_CONCURRENCY_TIMERMANAGER_H_

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

@@ -1,55 +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 "Util.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#if defined(HAVE_CLOCK_GETTIME)
-#include <time.h>
-#elif defined(HAVE_GETTIMEOFDAY)
-#include <sys/time.h>
-#endif // defined(HAVE_CLOCK_GETTIME)
-
-namespace apache { namespace thrift { namespace concurrency {
-
-const int64_t Util::currentTime() {
-  int64_t result;
-
-#if defined(HAVE_CLOCK_GETTIME)
-  struct timespec now;
-  int ret = clock_gettime(CLOCK_REALTIME, &now);
-  assert(ret == 0);
-  toMilliseconds(result, now);
-#elif defined(HAVE_GETTIMEOFDAY)
-  struct timeval now;
-  int ret = gettimeofday(&now, NULL);
-  assert(ret == 0);
-  toMilliseconds(result, now);
-#else
-#error "No high-precision clock is available."
-#endif // defined(HAVE_CLOCK_GETTIME)
-
-  return result;
-}
-
-
-}}} // apache::thrift::concurrency

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

@@ -1,100 +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_UTIL_H_
-#define _THRIFT_CONCURRENCY_UTIL_H_ 1
-
-#include <assert.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <time.h>
-#include <sys/time.h>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-/**
- * Utility methods
- *
- * This class contains basic utility methods for converting time formats,
- * and other common platform-dependent concurrency operations.
- * It should not be included in API headers for other concurrency library
- * headers, since it will, by definition, pull in all sorts of horrid
- * platform dependent crap.  Rather it should be inluded directly in
- * concurrency library implementation source.
- *
- * @version $Id:$
- */
-class Util {
-
-  static const int64_t NS_PER_S = 1000000000LL;
-  static const int64_t US_PER_S = 1000000LL;
-  static const int64_t MS_PER_S = 1000LL;
-
-  static const int64_t NS_PER_MS = NS_PER_S / MS_PER_S;
-  static const int64_t US_PER_MS = US_PER_S / MS_PER_S;
-
- public:
-
-  /**
-   * Converts millisecond timestamp into a timespec struct
-   *
-   * @param struct timespec& result
-   * @param time or duration in milliseconds
-   */
-  static void toTimespec(struct timespec& result, int64_t value) {
-    result.tv_sec = value / MS_PER_S; // ms to s
-    result.tv_nsec = (value % MS_PER_S) * NS_PER_MS; // ms to ns
-  }
-
-  static void toTimeval(struct timeval& result, int64_t value) {
-    result.tv_sec = value / MS_PER_S; // ms to s
-    result.tv_usec = (value % MS_PER_S) * US_PER_MS; // ms to us
-  }
-
-  /**
-   * Converts struct timespec to milliseconds
-   */
-  static const void toMilliseconds(int64_t& result, const struct timespec& value) {
-    result = (value.tv_sec * MS_PER_S) + (value.tv_nsec / NS_PER_MS);
-    // round up -- int64_t cast is to avoid a compiler error for some GCCs
-    if (int64_t(value.tv_nsec) % NS_PER_MS >= (NS_PER_MS / 2)) {
-      ++result;
-    }
-  }
-
-  /**
-   * Converts struct timeval to milliseconds
-   */
-  static const void toMilliseconds(int64_t& result, const struct timeval& value) {
-    result = (value.tv_sec * MS_PER_S) + (value.tv_usec / US_PER_MS);
-    // round up -- int64_t cast is to avoid a compiler error for some GCCs
-    if (int64_t(value.tv_usec) % US_PER_MS >= (US_PER_MS / 2)) {
-      ++result;
-    }
-  }
-
-  /**
-   * Get current time as milliseconds from epoch
-   */
-  static const int64_t currentTime();
-};
-
-}}} // apache::thrift::concurrency
-
-#endif // #ifndef _THRIFT_CONCURRENCY_UTIL_H_

data/vendor/gems/thrift/lib/cpp/src/concurrency/test/Tests.cpp

@@ -1,155 +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 <iostream>
-#include <vector>
-#include <string>
-
-#include "ThreadFactoryTests.h"
-#include "TimerManagerTests.h"
-#include "ThreadManagerTests.h"
-
-int main(int argc, char** argv) {
-
-  std::string arg;
-
-  std::vector<std::string>  args(argc - 1 > 1 ? argc - 1 : 1);
-
-  args[0] = "all";
-
-  for (int ix = 1; ix < argc; ix++) {
-    args[ix - 1] = std::string(argv[ix]);
-  }
-
-  bool runAll = args[0].compare("all") == 0;
-
-  if (runAll || args[0].compare("thread-factory") == 0) {
-
-    ThreadFactoryTests threadFactoryTests;
-
-    std::cout << "ThreadFactory tests..." << std::endl;
-
-    size_t count =  1000;
-    size_t floodLoops =  1;
-    size_t floodCount =  100000;
-
-    std::cout << "\t\tThreadFactory reap N threads test: N = " << count << std::endl;
-
-    assert(threadFactoryTests.reapNThreads(count));
-
-    std::cout << "\t\tThreadFactory floodN threads test: N = " << floodCount << std::endl;
-
-    assert(threadFactoryTests.floodNTest(floodLoops, floodCount));
-
-    std::cout << "\t\tThreadFactory synchronous start test" << std::endl;
-
-    assert(threadFactoryTests.synchStartTest());
-
-    std::cout << "\t\tThreadFactory monitor timeout test" << std::endl;
-
-    assert(threadFactoryTests.monitorTimeoutTest());
-  }
-
-  if (runAll || args[0].compare("util") == 0) {
-
-    std::cout << "Util tests..." << std::endl;
-
-    std::cout << "\t\tUtil minimum time" << std::endl;
-
-    int64_t time00 = Util::currentTime();
-    int64_t time01 = Util::currentTime();
-
-    std::cout << "\t\t\tMinimum time: " << time01 - time00 << "ms" << std::endl;
-
-    time00 = Util::currentTime();
-    time01 = time00;
-    size_t count = 0;
-
-    while (time01 < time00 + 10) {
-      count++;
-      time01 = Util::currentTime();
-    }
-
-    std::cout << "\t\t\tscall per ms: " << count / (time01 - time00) << std::endl;
-  }
-
-
-  if (runAll || args[0].compare("timer-manager") == 0) {
-
-    std::cout << "TimerManager tests..." << std::endl;
-
-    std::cout << "\t\tTimerManager test00" << std::endl;
-
-    TimerManagerTests timerManagerTests;
-
-    assert(timerManagerTests.test00());
-  }
-
-  if (runAll || args[0].compare("thread-manager") == 0) {
-
-    std::cout << "ThreadManager tests..." << std::endl;
-
-    {
-
-      size_t workerCount = 100;
-
-      size_t taskCount = 100000;
-
-      int64_t delay = 10LL;
-
-      std::cout << "\t\tThreadManager load test: worker count: " << workerCount << " task count: " << taskCount << " delay: " << delay << std::endl;
-
-      ThreadManagerTests threadManagerTests;
-
-      assert(threadManagerTests.loadTest(taskCount, delay, workerCount));
-
-      std::cout << "\t\tThreadManager block test: worker count: " << workerCount << " delay: " << delay << std::endl;
-
-      assert(threadManagerTests.blockTest(delay, workerCount));
-
-    }
-  }
-
-  if (runAll || args[0].compare("thread-manager-benchmark") == 0) {
-
-    std::cout << "ThreadManager benchmark tests..." << std::endl;
-
-    {
-
-      size_t minWorkerCount = 2;
-
-      size_t maxWorkerCount = 512;
-
-      size_t tasksPerWorker = 1000;
-
-      int64_t delay = 10LL;
-
-      for (size_t workerCount = minWorkerCount; workerCount < maxWorkerCount; workerCount*= 2) {
-
-        size_t taskCount = workerCount * tasksPerWorker;
-
-        std::cout << "\t\tThreadManager load test: worker count: " << workerCount << " task count: " << taskCount << " delay: " << delay << std::endl;
-
-        ThreadManagerTests threadManagerTests;
-
-        threadManagerTests.loadTest(taskCount, delay, workerCount);
-      }
-    }
-  }
-}