Example #1
0
  /// Start all io_service objects, default with non-bocked mode.
  void start(bool blocked = false)
  {
    if (!threads_.empty())
      return;

    {
      // Lock for synchronize access to data.
      scoped_lock_t lock(mutex_);

      blocked_ = blocked;

      // Create additional io_service pool.
      for (size_t i = io_services_.size(); i < pool_init_size_; ++i)
        io_services_.push_back(io_service_ptr(new boost::asio::io_service));

      // Release redundant io_service pool.
      for (size_t i = io_services_.size(); i > pool_init_size_; --i)
        io_services_.pop_back();

      // The pool is still idle now, set to true.
      idle_ = true;

      // Start all io_service.
      for (size_t i = io_services_.size(); i > 0 ; --i)
        start_one(io_services_[i - 1]);
    }

    // If in block mode, wait for all threads to exit.
    if (blocked_)
      wait();
  }
Example #2
0
  /// Start all io_service objects in the pool.
  void start(bool block)
  {
    if (threads_.size() != 0)
      return;

    // Start all io_service.
    for (std::size_t i = 0; i < io_services_.size(); ++i)
      start_one(io_services_[i]);
  
    block_ = block;
  
    if (block)
      wait();
  }
Example #3
0
  /// Get an io_service to use. if need then create one to use.
  boost::asio::io_service& get_io_service(std::size_t load)
  {
    // Calculate the required number of threads.
    std::size_t threads_number = load / pool_thread_load_;
    if ((threads_number > io_services_.size()) && (io_services_.size() < pool_high_watermark_) && !block_)
    {
      // Create new io_service and start it.
      io_service_ptr io_service(new boost::asio::io_service);
      io_services_.push_back(io_service);
      start_one(io_service);
      next_io_service_ = io_services_.size() - 1;
    }

    return get_io_service();
  }
Example #4
0
  /// Get an io_service to use. if need then create one to use.
  boost::asio::io_service& get_io_service(size_t load)
  {
    // Calculate the required number of threads.
    size_t threads_number = load / pool_thread_load_;

    // Lock for synchronize access to data.
    scoped_lock_t lock(mutex_);

    size_t service_count = io_services_.size();
    if (!blocked_                            && \
        !work_.empty()                       && \
        !threads_.empty()                    && \
        threads_number > service_count       && \
        service_count < pool_high_watermark_)
    {
      // Create new io_service and start it.
      io_service_ptr io_service(new boost::asio::io_service);
      io_services_.push_back(io_service);
      start_one(io_service);
      next_io_service_ = service_count;
    }

    return get_io_service();
  }