Processor.h

Go to the documentation of this file.

// Product  OpenNet


#pragma once

// Includes

// ===== Includes ===========================================================
#include <OpenNet/OpenNet.h>
#include <OpenNet/Status.h>

namespace OpenNet
{

    class UserBuffer;

    // Class

    class Processor
    {

    public:

        // TODO  OpenNet.Processor
        //       Normal (Feature) - Ajouter un chemin de recherche
        //       additionnel pour les includes dans la configuration.

        // TODO  OpenNet.Processor
        //       Normal (Feature) - Ajouter un parametre de configuration
        //       pour le chemin de recherche des include d'OpenNet.

        typedef struct
        {
            struct
            {
                unsigned mProfilingEnabled : 1;

                unsigned mReserved0 : 31;
            }
            mFlags;

            unsigned char mReserved0[60];
        }
        Config;

        typedef struct
        {
            uint64_t mGlobalMemCacheSize_byte   ;
            uint64_t mGlobalMemSize_byte        ;
            uint64_t mImage2DMaxHeight          ;
            uint64_t mImage2DMaxWidth           ;
            uint64_t mImage3DMaxDepth           ;
            uint64_t mImage3DMaxHeight          ;
            uint64_t mImage3DMaxWidth           ;
            uint64_t mLocalMemSize_byte         ;
            uint64_t mMaxConstantBufferSize_byte;
            uint64_t mMaxMemAllocSize_byte      ;
            uint64_t mMaxParameterSize_byte     ;
            uint64_t mMaxWorkGroupSize          ;
            uint64_t mMaxWorkItemSizes       [3];

            uint8_t mReserved0[8];

            uint32_t mGlobalMemCacheType         ;
            uint32_t mGlobalMemCacheLineSize_byte;
            uint32_t mLocalMemType               ;
            uint32_t mMaxComputeUnits            ;
            uint32_t mMaxConstantArgs            ;
            uint32_t mMaxReadImageArgs           ;
            uint32_t mMaxSamplers                ;
            uint32_t mMaxWriteImageArgs          ;
            uint32_t mMemBaseAddrAlign_bit       ;
            uint32_t mMinDataTypeAlignSize_byte  ;
            uint32_t mPreferredVectorWidthChar   ;
            uint32_t mPreferredVectorWidthShort  ;
            uint32_t mPreferredVectorWidthInt    ;
            uint32_t mPreferredVectorWidthLong   ;
            uint32_t mVendorId                   ;

            uint8_t mReserved1[64];

            struct
            {
                unsigned mAvailable         : 1;
                unsigned mCompilerAvailable : 1;
                unsigned mImageSupport      : 1;
                unsigned mEndianLittle      : 1;

                unsigned mReserved0 : 28;
            }
            mFlags;

            char mDriverVersion[128];
            char mName         [128];
            char mProfile      [128];
            char mVendor       [128];
            char mVersion      [128];

            uint8_t mReserved2[128];

        }
        Info;

        static OPEN_NET_PUBLIC Status Display(const Info & aIn, FILE * aOut);

        virtual Status GetConfig(Config * aOut) const = 0;

        virtual void * GetContext() = 0;

        virtual void * GetDevice() = 0;

        virtual Status GetInfo(Info * aOut) const = 0;

        virtual const char * GetName() const = 0;

        virtual Status SetConfig(const Config & aConfig) = 0;

        virtual UserBuffer * AllocateUserBuffer(unsigned int aSize_byte) = 0;

        virtual Status Display(FILE * aOut) const = 0;

    // Internal

        virtual ~Processor();

    protected:

        Processor();

    private:

        Processor(const Processor &);

        const Processor & operator = (const Processor &);

    };

}