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

Go to the documentation of this file.

#ifndef LAMA_CONTEXT_HPP_
#define LAMA_CONTEXT_HPP_

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

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

#include <lama/LAMATypes.hpp>

// logging
#include <logging/logging.hpp>

// boost
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>

namespace lama
{

class SyncToken;  // forward declaration

class Context;  // forward declaration

typedef boost::shared_ptr<const Context> ContextPtr;

class LAMA_DLL_IMPORTEXPORT Context : public Printable,
                                      private NonCopyable
{
public:

    enum ContextType { Host,        
                       CUDA,        
                       OpenCL,      
//                       NewContext,  //!< can be used for any new device
                       MaxContext   
                    };

    struct LAMA_DLL_IMPORTEXPORT ContextData : private NonCopyable
    {
        enum AccessKind
        {
            Read,            
            Write,           
            MaxAccessKind    
        };

        ContextPtr          context;   

        void*               pointer;   

        size_t              size;      

        bool                allocated; 

        bool                valid;     

        unsigned char       lock[MaxAccessKind]; 

        ContextData( ContextPtr context );

        ~ContextData();

        void allocate( const size_t size );

        void setRef( void* reference, const size_t size );

        void realloc( const size_t newSize, const size_t saveSize );

        void free();

        bool isPinned() const;

        void setPinned() const;

        void setCleanFunction( boost::function<void( void* )> cleanFunktion ) const;

    private:

        mutable bool pinned;

        mutable boost::function<void( void* )> mCleanFunktion;

        ContextData();   // disable default constructor
    };

    virtual ~Context();

    ContextType getType() const { return mContextType; }

    bool operator==(const Context& other) const;

    bool operator!=(const Context& other) const;

    virtual bool canUseData(const Context& other) const = 0;

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

    //virtual void* allocate( const size_t size ) const = 0;

    virtual void allocate( ContextData& contextData, const size_t size ) const = 0;

    virtual void free( void* pointer, const size_t size ) const = 0;

    virtual void free( ContextData& contextData ) const = 0;

    virtual void memcpy( void* dst, const void* src, const size_t size ) const = 0;

    virtual std::auto_ptr<SyncToken> memcpyAsync( void* dst, const void* src, const size_t size ) const = 0;

    virtual bool cancpy( const ContextData& dst, const ContextData& src ) const =0;

    virtual void memcpy( ContextData& dst, const ContextData& src, const size_t size ) const = 0;

    virtual std::auto_ptr<SyncToken> memcpyAsync( ContextData& dst, const ContextData& src, const size_t size ) const = 0;

    virtual std::auto_ptr<SyncToken> getSyncToken() const = 0;

    virtual void enable( const char* file, int line ) const;

    virtual void disable( const char* file, int line ) const;

    const class LAMAInterface& getInterface() const;

protected:

    Context( ContextType type );

    LAMA_LOG_DECL_STATIC_LOGGER(logger);

    ContextType mContextType;

    mutable bool mEnabled;       

    mutable const char* mFile;   

    mutable int mLine;           
};

typedef Context::ContextType ContextType;

LAMA_DLL_IMPORTEXPORT std::ostream& operator<<(std::ostream& stream, const ContextType type);

}

#endif // LAMA_CONTEXT_HPP_