apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer > 模板类 参考

#include <concurrent_object_pool.h>

类 apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer > 继承关系图:

apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer > 的协作图:

Public 成员函数
std::shared_ptr< ObjectType >	Get () override
void	BatchGet (size_t num, std::vector< std::shared_ptr< ObjectType > > *data) override
void	BatchGet (size_t num, bool is_front, std::list< std::shared_ptr< ObjectType > > *data) override
void	BatchGet (size_t num, bool is_front, std::deque< std::shared_ptr< ObjectType > > *data) override
	~ConcurrentObjectPool () override
Public 成员函数 继承自 apollo::perception::base::BaseObjectPool< ObjectType >
	BaseObjectPool ()=default
virtual	~BaseObjectPool ()=default
virtual void	set_capacity (size_t capacity)
size_t	get_capacity ()
virtual size_t	RemainedNum ()

静态 Public 成员函数
static ConcurrentObjectPool &	Instance ()

Protected 成员函数
	ConcurrentObjectPool (const size_t default_size)
Protected 成员函数 继承自 apollo::perception::base::BaseObjectPool< ObjectType >
	BaseObjectPool (const BaseObjectPool &rhs)=delete
BaseObjectPool &	operator= (const BaseObjectPool &rhs)=delete

Protected 属性
std::mutex	mutex_
std::queue< ObjectType * >	queue_
ObjectType *	cache_ = nullptr
const size_t	kDefaultCacheSize
std::list< ObjectType * >	extended_cache_
Protected 属性 继承自 apollo::perception::base::BaseObjectPool< ObjectType >
size_t	capacity_ = 0

静态 Protected 属性
static const Initializer	kInitializer

详细描述

template<class ObjectType, size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>
class apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >

在文件 concurrent_object_pool.h 第 43 行定义.

构造及析构函数说明

~ConcurrentObjectPool()

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::~ConcurrentObjectPool ( )

inlineoverride

在文件 concurrent_object_pool.h 第 201 行定义.

                                   {
    if (cache_) {
      delete[] cache_;
      cache_ = nullptr;
    }
    for (auto& ptr : extended_cache_) {
      delete ptr;
    }
    extended_cache_.clear();
  }

ConcurrentObjectPool()

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::ConcurrentObjectPool ( const size_t  default_size )

inlineexplicitprotected

在文件 concurrent_object_pool.h 第 225 行定义.

      : kDefaultCacheSize(default_size) {
#ifndef PERCEPTION_BASE_DISABLE_POOL
    cache_ = new ObjectType[kDefaultCacheSize];
    for (size_t i = 0; i < kDefaultCacheSize; ++i) {
      queue_.push(&cache_[i]);
    }
    capacity_ = kDefaultCacheSize;
#endif
  }

成员函数说明

BatchGet() [1/3]

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

void apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::BatchGet ( size_t  num, bool  is_front, std::deque< std::shared_ptr< ObjectType > > *  data  )

inlineoverridevirtual

实现了 apollo::perception::base::BaseObjectPool< ObjectType >.

在文件 concurrent_object_pool.h 第 154 行定义.

                                                                    {
#ifndef PERCEPTION_BASE_DISABLE_POOL
    std::vector<ObjectType*> buffer(num, nullptr);
    {
      std::lock_guard<std::mutex> lock(mutex_);
      if (queue_.size() < num) {
        Add(num - queue_.size() + kPoolDefaultExtendNum);
      }
      for (size_t i = 0; i < num; ++i) {
        buffer[i] = queue_.front();
        queue_.pop();
      }
    }
    for (size_t i = 0; i < num; ++i) {
      kInitializer(buffer[i]);
      is_front ? data->emplace_front(std::shared_ptr<ObjectType>(
                     buffer[i],
                     [&](ObjectType* obj_ptr) {
                       std::lock_guard<std::mutex> lock(mutex_);
                       queue_.push(obj_ptr);
                     }))
               : data->emplace_back(std::shared_ptr<ObjectType>(
                     buffer[i], [&](ObjectType* obj_ptr) {
                       std::lock_guard<std::mutex> lock(mutex_);
                       queue_.push(obj_ptr);
                     }));
    }
#else
    for (size_t i = 0; i < num; ++i) {
      is_front ? data->emplace_front(new ObjectType)
               : data->emplace_back(new ObjectType);
    }
#endif
  }

BatchGet() [2/3]

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

void apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::BatchGet ( size_t  num, bool  is_front, std::list< std::shared_ptr< ObjectType > > *  data  )

inlineoverridevirtual

实现了 apollo::perception::base::BaseObjectPool< ObjectType >.

在文件 concurrent_object_pool.h 第 113 行定义.

                                                                   {
#ifndef PERCEPTION_BASE_DISABLE_POOL
    std::vector<ObjectType*> buffer(num, nullptr);
    {
      std::lock_guard<std::mutex> lock(mutex_);
      if (queue_.size() < num) {
        Add(num - queue_.size() + kPoolDefaultExtendNum);
      }
      for (size_t i = 0; i < num; ++i) {
        buffer[i] = queue_.front();
        queue_.pop();
      }
    }
    // For efficiency consideration, initialization should be invoked
    // after releasing the mutex
    for (size_t i = 0; i < num; ++i) {
      kInitializer(buffer[i]);
      is_front ? data->emplace_front(std::shared_ptr<ObjectType>(
                     buffer[i],
                     [&](ObjectType* obj_ptr) {
                       std::lock_guard<std::mutex> lock(mutex_);
                       queue_.push(obj_ptr);
                     }))
               : data->emplace_back(std::shared_ptr<ObjectType>(
                     buffer[i], [&](ObjectType* obj_ptr) {
                       std::lock_guard<std::mutex> lock(mutex_);
                       queue_.push(obj_ptr);
                     }));
    }
#else
    for (size_t i = 0; i < num; ++i) {
      is_front ? data->emplace_front(new ObjectType)
               : data->emplace_back(new ObjectType);
    }
#endif
  }

BatchGet() [3/3]

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

void apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::BatchGet ( size_t  num, std::vector< std::shared_ptr< ObjectType > > *  data  )

inlineoverridevirtual

实现了 apollo::perception::base::BaseObjectPool< ObjectType >.

在文件 concurrent_object_pool.h 第 79 行定义.

                                                                     {
#ifndef PERCEPTION_BASE_DISABLE_POOL
    std::vector<ObjectType*> buffer(num, nullptr);
    {
      std::lock_guard<std::mutex> lock(mutex_);
      if (queue_.size() < num) {
        Add(num - queue_.size() + kPoolDefaultExtendNum);
      }
      for (size_t i = 0; i < num; ++i) {
        buffer[i] = queue_.front();
        queue_.pop();
      }
    }
    // For efficiency consideration, initialization should be invoked
    // after releasing the mutex
    for (size_t i = 0; i < num; ++i) {
      kInitializer(buffer[i]);
      data->emplace_back(
          std::shared_ptr<ObjectType>(buffer[i], [&](ObjectType* obj_ptr) {
            std::lock_guard<std::mutex> lock(mutex_);
            queue_.push(obj_ptr);
          }));
    }
#else
    for (size_t i = 0; i < num; ++i) {
      data->emplace_back(new ObjectType);
    }
#endif
  }

Get()

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

std::shared_ptr< ObjectType > apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::Get ( )

inlineoverridevirtual

实现了 apollo::perception::base::BaseObjectPool< ObjectType >.

在文件 concurrent_object_pool.h 第 53 行定义.

                                           {
// TODO(All): remove conditional build
#ifndef PERCEPTION_BASE_DISABLE_POOL
    ObjectType* ptr = nullptr;
    {
      std::lock_guard<std::mutex> lock(mutex_);
      if (queue_.empty()) {
        Add(1 + kPoolDefaultExtendNum);
      }
      ptr = queue_.front();
      queue_.pop();
    }
    // For efficiency consideration, initialization should be invoked
    // after releasing the mutex
    kInitializer(ptr);
    return std::shared_ptr<ObjectType>(ptr, [&](ObjectType* obj_ptr) {
      std::lock_guard<std::mutex> lock(mutex_);
      queue_.push(obj_ptr);
    });
#else
    return std::shared_ptr<ObjectType>(new ObjectType);
#endif
  }

Instance()

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

static ConcurrentObjectPool & apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::Instance ( )

inlinestatic

在文件 concurrent_object_pool.h 第 48 行定义.

                                          {
    static ConcurrentObjectPool pool(N);
    return pool;
  }

类成员变量说明

cache_

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

ObjectType* apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::cache_ = nullptr

protected

在文件 concurrent_object_pool.h 第 238 行定义.

extended_cache_

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

std::list<ObjectType*> apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::extended_cache_

protected

在文件 concurrent_object_pool.h 第 241 行定义.

kDefaultCacheSize

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

const size_t apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::kDefaultCacheSize

protected

在文件 concurrent_object_pool.h 第 239 行定义.

kInitializer

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

const Initializer apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::kInitializer

staticprotected

在文件 concurrent_object_pool.h 第 242 行定义.

mutex_

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

std::mutex apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::mutex_

protected

在文件 concurrent_object_pool.h 第 235 行定义.

queue_

template<class ObjectType , size_t N = kPoolDefaultSize, class Initializer = ObjectPoolDefaultInitializer<ObjectType>>

std::queue<ObjectType*> apollo::perception::base::ConcurrentObjectPool< ObjectType, N, Initializer >::queue_

protected

在文件 concurrent_object_pool.h 第 236 行定义.

---

该类的文档由以下文件生成:

• modules/perception/common/base/concurrent_object_pool.h