/home/brandes/workspace/LAMA/src/lama/LAMAArray.hpp

Go to the documentation of this file.

#ifndef LAMA_LAMA_ARRAY_HPP_
#define LAMA_LAMA_ARRAY_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/Printable.hpp>

// others
#include <lama/LAMATypes.hpp>
#include <lama/Context.hpp>
#include <lama/Scalar.hpp>

// boost
#include <boost/thread/recursive_mutex.hpp>

#include <vector>

#define LAMA_MAX_CONTEXTS 4

namespace lama
{

class SyncToken;

// Forward declaration of friend classes.

template<typename T>
class LAMAArrayView;

template<typename T>
class LAMAArrayConstView;

class LAMA_DLL_IMPORTEXPORT _LAMAArray : public Printable
{

public:

    virtual ~_LAMAArray() {}

    virtual Scalar::ScalarType getValueType() const = 0;

    static std::auto_ptr<_LAMAArray> create( const Scalar::ScalarType );

    inline IndexType size() const;

protected:

    explicit _LAMAArray( const IndexType n ) : mSize( n ), constFlag( false )  {}

    IndexType mSize;  

    bool constFlag;   

    static size_t nContextIndex;    // stands for no valid index
};

template<typename T>
class LAMA_DLL_IMPORTEXPORT LAMAArray : public _LAMAArray
{
    friend class LAMAArrayView<T>;
    friend class LAMAArrayConstView<T>;

public:

    typedef T ValueType;

    LAMAArray( );

    explicit LAMAArray( const IndexType n );

    LAMAArray( const IndexType n, const ValueType& value );

    template<typename OtherValueType>
    LAMAArray( const IndexType n, const OtherValueType* const values );

    LAMAArray( const LAMAArray<ValueType>& other );

    virtual ~LAMAArray();

    LAMAArray<ValueType>& operator= ( const LAMAArray<ValueType>& other );

    void assign( const LAMAArray<ValueType>& other, ContextPtr context );

    void swap( LAMAArray<ValueType>& other );

    void prefetch( ContextPtr context ) const;

    bool isAvailableAt( ContextPtr context ) const;

    ContextPtr getValidContext( const Context::ContextType preferredType = Context::Host) const;

    void wait() const;

    void clear();

    void purge();

    virtual void writeAt( std::ostream& stream ) const;

    virtual Scalar::ScalarType getValueType() const;

protected:

    using _LAMAArray::mSize;
    using _LAMAArray::constFlag;

    ValueType* get( size_t index );

    const ValueType* get( const size_t index ) const;

    void clear( const size_t index );

    void resize( const size_t index, const IndexType newSize );

    void reserve( const size_t index, const IndexType capacity, const bool copy ) const;

    IndexType capacity( const size_t index ) const;

    int acquireReadAccess( ContextPtr context ) const;

    void releaseReadAccess( const size_t index ) const;

    int acquireWriteAccess( ContextPtr context, bool keepFlag );

    int acquireWriteAccess();

    void releaseWriteAccess( const size_t index );

    void copy( const int toIndex, const int fromIndex ) const;

    void fetch( Context::ContextData& target, const Context::ContextData& source ) const;

    std::auto_ptr<SyncToken> fetchAsync( Context::ContextData& target, const Context::ContextData& source ) const;

    void getAccess( size_t& contextIndex, size_t& validIndex,
                    ContextPtr context, Context::ContextData::AccessKind kind ) const;

    void setHostContext();

    mutable std::vector<Context::ContextData*> mContextData;   // available context, pointers are never NULL

    mutable std::auto_ptr<SyncToken> mSyncToken;  

    LAMA_LOG_DECL_STATIC_LOGGER( logger );

    static size_t nContextIndex;    // stands for no valid index

    mutable boost::recursive_mutex access_mutex;  // needed to make accesses thread-safe
};

template<typename T>
class LAMA_DLL_IMPORTEXPORT LAMAArrayRef : public LAMAArray<T>
{
public:

    LAMAArrayRef( T* pointer, IndexType size );

    LAMAArrayRef( const T* pointer, IndexType size );

protected:

    using LAMAArray<T>::mSize;

    using LAMAArray<T>::mContextData;
    using LAMAArray<T>::constFlag;
};

/* ---------------------------------------------------------------------------------*/

inline IndexType _LAMAArray::size() const
{
    return mSize;
}

/* ---------------------------------------------------------------------------------*/

template<typename ValueType>
template<typename OtherValueType>
LAMAArray<ValueType>::LAMAArray( const IndexType n, const OtherValueType* const values )
    : _LAMAArray( n ),
      mSyncToken( 0 )
{
    setHostContext();

    if ( n <= 0 )
    {
        LAMA_LOG_DEBUG( logger, "Zero-sized array with value constructed: " << *this );
        return;
    }

    Context::ContextData& host = *mContextData[0];
    host.allocate( mSize * sizeof(ValueType) );
    LAMA_LOG_DEBUG( logger, "constructed: " << *this );

    ValueType* host_pointer = static_cast<ValueType*>( host.pointer );

    #pragma omp parallel for schedule(LAMA_OMP_SCHEDULE)
    for ( int i = 0; i < mSize; ++i )
    {
        host_pointer[i] = static_cast<ValueType>( values[i] );
    }

    host.valid = true;
    LAMA_LOG_DEBUG( logger, "constructed: " << *this );
}

}

#endif // LAMA_LAMA_ARRAY_HPP_