STL vector and unique_ptr with custom deleter classes - c++

Question

I have some c++ code that compiles with clang 3.2-7 and gcc 4.8.1 but not with gcc 4.6.3. I'm compiling with c++0x.
I'm implementing a 'ResourcePool' that manages a fixed set of resources. It allocates resources out by providing a unique_ptr with a custom deleter class; when the object requesting the resource drops out of scope, the deleter returns the resource to a pool.
The deleter class looks like so:
template <typename T>
class ResourcePoolManager {
public:
ResourcePoolManager(ResourcePool<T> & pool)
: pool(pool)
{
}
~ResourcePoolManager() {};
void operator()(T* releasedResource) const {
pool.releaseResource(releasedResource);
}
private:
ResourcePool<T> & pool;
};
The pool itself looks like (edited unrelated methods out):
template <typename T>
class ResourcePool {
public:
ResourcePool()
: manager(*this)
{
}
std::unique_ptr<T, ResourcePoolManager<T>> requestResource() {
if(availableResources.size() == 0) {
return std::unique_ptr<T, ResourcePoolManager<T>>(NULL, manager);
} else {
T * resource = availableResources.front();
availableResources.pop_front();
return std::unique_ptr<T, ResourcePoolManager<T>>(resource, manager);
}
}
private:
friend class ResourcePoolManager<T>;
void releaseResource(T * releasedResource) {
availableResources.push_back(releasedResource);
}
ResourcePoolManager<T> manager;
std::deque<T *> availableResources;
std::deque<T *> allResources;
};
The problem occurs when I try to pull resources out of the pool and store them in a std::vector; where OpenCLDevice is the resource in question:
ResourcePool<OpenCLDevice> computeDevicePool;
std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice>> devicePtr = computeDevicePool.requestResource();
std::vector<std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice>>> gpus;
gpus.push_back(std::move(devicePtr));
As mentioned up top, clang and a newer version are gcc are fine with this. However gcc 4.6.3 is coming out with:
/usr/include/c++/4.6/bits/unique_ptr.h: In member function 'std::unique_ptr<_Tp, _Dp>& std::unique_ptr<_Tp, _Dp>::operator=(std::unique_ptr<_Tp, _Dp>&&) [with _Tp = OpenCLDevice, _Dp = ResourcePoolManager<OpenCLDevice>, std::unique_ptr<_Tp, _Dp> = std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >]':
/usr/include/c++/4.6/bits/vector.tcc:319:4: instantiated from 'void std::vector<_Tp, _Alloc>::_M_insert_aux(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >}, _Tp = std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >, _Alloc = std::allocator<std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> > >, std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >*, std::vector<std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> > > >, typename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type::pointer = std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >*]'
/usr/include/c++/4.6/bits/vector.tcc:102:4: instantiated from 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >}, _Tp = std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >, _Alloc = std::allocator<std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> > >]'
/usr/include/c++/4.6/bits/stl_vector.h:840:9: instantiated from 'void std::vector<_Tp, _Alloc>::push_back(std::vector<_Tp, _Alloc>::value_type&&) [with _Tp = std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >, _Alloc = std::allocator<std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> > >, std::vector<_Tp, _Alloc>::value_type = std::unique_ptr<OpenCLDevice, ResourcePoolManager<OpenCLDevice> >]'
trunk/src/dpa/distinguishers/GenericOpenCLDPA.cpp:109:39: instantiated from here
/usr/include/c++/4.6/bits/unique_ptr.h:176:2: error: use of deleted function 'ResourcePoolManager<OpenCLDevice>& ResourcePoolManager<OpenCLDevice>::operator=(const ResourcePoolManager<OpenCLDevice>&)'
ResourcePool.hpp:30:7 error: 'ResourcePoolManager<OpenCLDevice> & ResourcePoolManager<OpenCLDevice>::operator=(const ResourcePoolManager<OpenCLDevice>&)'
is implicitly deleted because the default definition would be ill-formed:
ResourcePool.hpp:30:7: error: non-static reference member 'ResourcePool<OpenCLDevice>& ResourcePoolManager<OpenCLDevice>::pool', can't use default assignment operator
The compiler stops at the final line where the pointer is moved into the gpus vector, indicating to me that something is being copied when it shouldn't be. Line 30 is the definition of the ResourcePoolManager class class ResourcePoolManager {.
Am I doing something incorrectly with the management of the custom deleter where the newer compilers are letting me get away with things?

Answer 1

Looks like a bug in the libstdc++ 4.6 unique_ptr that expects the deleter type to be copyable. Changing ResourcePoolManager::pool to a pointer instead of a reference is an effective workaround.
More specifically, this program reproduces the bug:
#include <memory>
#include <vector>
struct deleter {
deleter() : c(*"") {}
void operator () (int *) const {}
deleter(deleter&&) = default;
deleter& operator = (deleter&&) = default;
const char& c;
};
int main() {
std::vector<std::unique_ptr<int, deleter>> vec;
vec.push_back(std::unique_ptr<int, deleter>{});
}
simply declaring the vector is fine, its the instantiation of push_back that fails.
Clarification: the issue seems to be that the 4.6 implementation of vector is using = to move assign elements when it resizes, whereas the 4.8 implementation is exclusively using move construction. A class with a reference member - such as your deleter - is move constructible, but not move (or copy, for that matter) assignable. You can see the same error message in 4.8 if you assign to the vector:
int main() {
std::vector<std::unique_ptr<int, deleter>> vec;
vec.push_back(std::unique_ptr<int, deleter>{new int(42)});
vec[0] = std::unique_ptr<int, deleter>{new int(42)};
}
std::vector::push_back is specified to require only that T be MoveInsertable, so I believe this is certainly a bug in libstdc++ 4.6.