shared_ptr.hpp

Go to the documentation of this file.

/*
Copyright (c) 2014-2016, Scott Zuyderduyn
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
*/

//----------------------------------------------------------------------------
// ptr/shared_ptr.hpp
//
// A managed, reference-counted pointer to device memory.
//
// Author: Scott D. Zuyderduyn, Ph.D. (scott.zuyderduyn@utoronto.ca)
//----------------------------------------------------------------------------

#ifndef ECUDA_PTR_SHARED_PTR_HPP
#define ECUDA_PTR_SHARED_PTR_HPP

#include <iostream>

#include "../global.hpp"
#include "common.hpp"
#include "../algorithm.hpp"

//
// Implementation is the approach used by boost::shared_ptr.
//
// \todo STL contains means to use a custom allocator to allocate memory for the internal counter
//       but this hasn't been done here (things are overengineered enough atm!) - if a programmer
//       were to take the approach of allocating a lot of individual shared_ptr managing many
//       different objects, there is a potential performance benefit from allowing a task-optimized
//       custom allocator
//

namespace ecuda {

namespace detail {

struct sp_counter_base
{
    std::size_t owner_count;
    sp_counter_base() : owner_count(1) {}
    virtual ~sp_counter_base() {}
    virtual void dispose( void* ) = 0;
    virtual void* get_deleter() { return 0; }
};

template<typename T>
struct sp_counter_impl_p : sp_counter_base
{
    sp_counter_impl_p() : sp_counter_base() {}
    virtual void dispose( void* p ) { if( p ) ecuda::default_device_delete<void>()(p); } // cudaFree( p );
};

template<typename T,class Deleter>
struct sp_counter_impl_pd : sp_counter_base
{
    Deleter deleter;
    sp_counter_impl_pd( Deleter deleter ) : sp_counter_base(), deleter(deleter) {}
    virtual void dispose( void* p ) { if( p ) deleter(p); }
    //virtual void* get_deleter() { return deleter; }
    virtual void* get_deleter() { return reinterpret_cast<void*>(&deleter); }
};

} // namespace detail

template<typename T>
class shared_ptr
{

public:
    typedef T element_type; 

private:
    void* current_ptr; 
    detail::sp_counter_base* counter; 

    template<typename U> friend class shared_ptr;

public:

    __HOST__ __DEVICE__ __CONSTEXPR__ shared_ptr() __NOEXCEPT__ : current_ptr(NULL), counter(NULL) {}

    template<typename U>
    __HOST__ __DEVICE__ explicit shared_ptr( U* ptr ) : current_ptr(detail::void_cast<T*>()(ptr)), counter(NULL)
    {
        #ifndef __CUDA_ARCH__
        if( ptr ) counter = new detail::sp_counter_impl_p<T>();
        #endif
    }

    template<typename U,class Deleter>
    __HOST__ __DEVICE__ shared_ptr( U* ptr, Deleter deleter ) : current_ptr(detail::void_cast<T*>()(ptr)), counter(NULL)
    {
        #ifndef __CUDA_ARCH__
        if( ptr ) counter = new detail::sp_counter_impl_pd<T,Deleter>( deleter );
        #endif
    }

    template<typename U>
    __HOST__ __DEVICE__ shared_ptr( const shared_ptr<U>& src, T* ptr ) __NOEXCEPT__ : current_ptr(ptr), counter(src.counter)
    {
        #ifndef __CUDA_ARCH__
        ++(counter->owner_count);
        #endif
    }

    __HOST__ __DEVICE__ shared_ptr( const shared_ptr& src ) __NOEXCEPT__ : current_ptr(src.current_ptr), counter(src.counter)
    {
        #ifndef __CUDA_ARCH__
        if( counter ) ++(counter->owner_count);
        #endif
    }

    template<typename U>
    __HOST__ __DEVICE__ shared_ptr( const shared_ptr<U>& src ) __NOEXCEPT__ : current_ptr(src.current_ptr), counter(src.counter)
    {
        #ifndef __CUDA_ARCH__
        if( counter ) ++(counter->owner_count);
        #endif
    }

    #ifdef ECUDA_CPP11_AVAILABLE
    __HOST__ __DEVICE__ shared_ptr( shared_ptr&& src ) __NOEXCEPT__ : current_ptr(std::move(src.current_ptr)), counter(std::move(src.counter))
    {
        //src.current_ptr = NULL;
        //src.counter = NULL;
    }

    template<typename U>
    __HOST__ __DEVICE__ shared_ptr( shared_ptr<U>&& src ) __NOEXCEPT__ : current_ptr(std::move(src.current_ptr)), counter(std::move(src.counter))
    {
        //src.current_ptr = NULL;
        //src.counter = NULL;
    }

    template<typename U,class Deleter>
    __HOST__ __DEVICE__ shared_ptr( ecuda::unique_ptr<U,Deleter>&& src ) : current_ptr(detail::void_cast<T*>()(src.release()))
    {
       counter = current_ptr ? new detail::sp_counter_impl_pd<T,Deleter>( src.get_deleter() ) : NULL;
    }
    #endif

    __HOST__ __DEVICE__ ~shared_ptr()
    {
        #ifndef __CUDA_ARCH__
        if( counter ) {
            --(counter->owner_count);
            if( counter->owner_count == 0 ) {
                counter->dispose( current_ptr );
                delete counter;
                counter = NULL;
            }
        }
        #endif
    }

    __HOST__ __DEVICE__ inline shared_ptr& operator=( const shared_ptr& src ) __NOEXCEPT__
    {
        shared_ptr(src).swap(*this);
        return *this;
    }

    template<typename U> __HOST__ __DEVICE__ inline shared_ptr& operator=( const shared_ptr<U>& src ) __NOEXCEPT__ { shared_ptr(src).swap(*this); return *this; }

    #ifdef ECUDA_CPP11_AVAILABLE
    __HOST__ __DEVICE__ inline shared_ptr& operator=( shared_ptr&& src ) __NOEXCEPT__ { shared_ptr(move(src)).swap(*this); return *this; }

    template<typename U> __HOST__ __DEVICE__ inline shared_ptr& operator=( shared_ptr<U>&& src ) __NOEXCEPT__ { shared_ptr(move(src)).swap(*this); return *this; }

    template<typename U,class Deleter> __HOST__ __DEVICE__ inline shared_ptr& operator=( unique_ptr<U,Deleter>&& src ) __NOEXCEPT__ { shared_ptr(move(src)).swap(*this); return *this; }
    #endif

    __HOST__ __DEVICE__ inline void reset() __NOEXCEPT__ { shared_ptr().swap( *this ); }

    template<typename U> __HOST__ __DEVICE__ inline void reset( U* ptr ) { shared_ptr( ptr ).swap( *this ); }

    template<typename U,class Deleter> __HOST__ __DEVICE__ inline void reset( U* ptr, Deleter d ) { shared_ptr( ptr, d ).swap( *this ); }

    __HOST__ __DEVICE__ inline void swap( shared_ptr& other ) __NOEXCEPT__
    {
        ::ecuda::swap( current_ptr, other.current_ptr );
        ::ecuda::swap( counter, other.counter );
    }

    __HOST__ __DEVICE__ inline T* get() const __NOEXCEPT__ { return reinterpret_cast<T*>(current_ptr); }

    __DEVICE__ inline typename ecuda::add_lvalue_reference<T>::type operator*() const __NOEXCEPT__ { return *reinterpret_cast<T*>(current_ptr); }

    __HOST__ __DEVICE__ inline T* operator->() const __NOEXCEPT__ { return reinterpret_cast<T*>(current_ptr); }

    __HOST__ __DEVICE__ inline std::size_t use_count() const __NOEXCEPT__ { return counter ? counter->owner_count : 0; }

    __HOST__ __DEVICE__ inline bool unique() const __NOEXCEPT__ { return use_count() == 1; }

    #ifdef ECUDA_CPP11_AVAILABLE
    __HOST__ __DEVICE__ explicit operator bool() const __NOEXCEPT__ { return get() != NULL; }
    #else
    __HOST__ __DEVICE__ operator bool() const __NOEXCEPT__ { return get() != NULL; }
    #endif

    template<typename U>
    __HOST__ __DEVICE__ inline bool owner_before( const shared_ptr<U>& other ) const { return counter < other.counter; }

    template<typename T2> __HOST__ __DEVICE__ bool operator==( const shared_ptr<T2>& other ) const __NOEXCEPT__ { return get() == other.get(); }
    template<typename T2> __HOST__ __DEVICE__ bool operator!=( const shared_ptr<T2>& other ) const __NOEXCEPT__ { return get() != other.get(); }
    template<typename T2> __HOST__ __DEVICE__ bool operator< ( const shared_ptr<T2>& other ) const __NOEXCEPT__ { return get() <  other.get(); }
    template<typename T2> __HOST__ __DEVICE__ bool operator> ( const shared_ptr<T2>& other ) const __NOEXCEPT__ { return get() >  other.get(); }
    template<typename T2> __HOST__ __DEVICE__ bool operator<=( const shared_ptr<T2>& other ) const __NOEXCEPT__ { return get() <= other.get(); }
    template<typename T2> __HOST__ __DEVICE__ bool operator>=( const shared_ptr<T2>& other ) const __NOEXCEPT__ { return get() >= other.get(); }

    template<typename U,typename V>
    friend std::basic_ostream<U,V>& operator<<( std::basic_ostream<U,V>& out, const shared_ptr& ptr )
    {
        out << ptr.get();
        return out;
    }

};

} // namespace ecuda

#endif