PassThroughDevice.h

Go to the documentation of this file.

#ifndef OCELOT_PASSTHROUGHDEVICE_H_INCLUDED
#define OCELOT_PASSTHROUGHDEVICE_H_INCLUDED

// Ocelot includes
#include <ocelot/executive/interface/Device.h>
#include <ocelot/util/interface/ExtractedDeviceState.h>

namespace executive
{
  class ExecutableKernel;
}

namespace executive 
{
  class PassThroughDevice: public Device 
  {
    public:
      bool checkMemoryAccess(const void* pointer, 
        size_t size) const;
      Device::MemoryAllocation* getMemoryAllocation(const void* address, 
        AllocationType type = DeviceAllocation) const;
      Device::MemoryAllocation* getGlobalAllocation(
        const std::string& module, const std::string& name);
      Device::MemoryAllocation* allocate(size_t size);
      Device::MemoryAllocation* allocateHost(size_t size, 
        unsigned int flags = 0);
      Device::MemoryAllocation* registerHost(void* pointer, size_t size, 
        unsigned int flags);
      void free(void* pointer);
      Device::MemoryAllocationVector getNearbyAllocations(
        void* pointer) const;
      Device::MemoryAllocationVector getAllAllocations() const;
      std::string nearbyAllocationsToString(void* pointer) const;
      void clearMemory();
    
    public:
      void* glRegisterBuffer(unsigned int buffer, 
        unsigned int flags);
      void* glRegisterImage(unsigned int image, 
        unsigned int target, unsigned int flags);
      void unRegisterGraphicsResource(void* resource);
      void mapGraphicsResource(void** resource, int count, 
        unsigned int stream);
      void* getPointerToMappedGraphicsResource(size_t& size, 
        void* resource);
      void setGraphicsResourceFlags(void* resource, 
        unsigned int flags);
      void unmapGraphicsResource(void** resource, int count,
        unsigned int stream);

    public:
      void load(const ir::Module* module);
      void unload(const std::string& name);
      ExecutableKernel* getKernel(const std::string& module, 
        const std::string& kernel);

    public:
      unsigned int createEvent(int flags);
      void destroyEvent(unsigned int event);
      bool queryEvent(unsigned int event);
      void recordEvent(unsigned int event, 
        unsigned int stream);
      void synchronizeEvent(unsigned int event);
      float getEventTime(unsigned int start, 
        unsigned int end);
    
    public:
      unsigned int createStream();
      void destroyStream(unsigned int stream);
      bool queryStream(unsigned int stream);
      void synchronizeStream(unsigned int stream);
      void setStream(unsigned int stream);
      
    public:
      void select();
      bool selected();
      void unselect();
    
    public:
      void bindTexture(void* pointer, 
        const std::string& moduleName, const std::string& textureName,
        const textureReference& ref, const cudaChannelFormatDesc& desc, 
        const ir::Dim3& size);
      void unbindTexture(const std::string& moduleName, 
        const std::string& textureName);
      void* getTextureReference(const std::string& moduleName, 
        const std::string& textureName);
    
    public:
      void launch(const std::string& module, 
        const std::string& kernel, const ir::Dim3& grid, 
        const ir::Dim3& block, size_t sharedMemory, 
        const void* argumentBlock, size_t argumentBlockSize, 
        const trace::TraceGeneratorVector& 
        traceGenerators = trace::TraceGeneratorVector(),
        const ir::ExternalFunctionSet* externals = 0);
      cudaFuncAttributes getAttributes(const std::string& module, 
        const std::string& kernel);
      unsigned int getLastError();
      void synchronize();
      
    public:
      void limitWorkerThreads(unsigned int threads);
      void setOptimizationLevel(
        translator::Translator::OptimizationLevel level);
      
    public:
      PassThroughDevice(Device *target, unsigned int flags = 0);
      ~PassThroughDevice();

    private:
      typedef std::vector<const ir::Module*> ModuleVector;

    private:
      void _recordStatePreExecution();
      
      void _recordKernelLaunch(const std::string& module, 
        const std::string& kernel, 
        const ir::Dim3& grid, 
        const ir::Dim3& block, 
        size_t sharedMemory, 
        const void* argumentBlock, 
        size_t argumentBlockSize);

      void _recordStatePostExecution();

    private:
      unsigned int _kernelCount;
    
      util::ExtractedDeviceState _state;
      
      Device* _target;
      
      ModuleVector _modules;      
  };
}

#endif