GxSysFile.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxSysFile : public GxSysBase, public SingletonBase<GxSysFile>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_ABSTRACT_CLASS(GxSysFile, GxSysBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSysFile)
 
    
    static constexpr u32 REQUEST_BUFFER_MAX = GxMath::VALUE_32;
    static constexpr u32 READ_ASYNC_ONE_SIZE = GxMath::VALUE_128K;
 
    enum class REQUEST_PRIORITY
    {
        HIGH = 0,                       
        MIDDLE,                         
        LOW,                            
        MAX                             
    };
 
    enum class REQUEST_STATE
    {
        READ = 0,                       
        CANCEL                          
    };
 
    enum class ASYNC_RESULT
    {
        CANCELED = -2,                  
        ERROR_  = -1,                   
        PROGRESS = 0,                   
        SUCCESS                         
    };
 
    typedef void (*REQUEST_START_CALLBACK_FUNCTION)(void* pUser, GX_HANDLE requestHandle);
    typedef void (*REQUEST_END_CALLBACK_FUNCTION)(void* pUser, GX_HANDLE requestHandle, GxSysFile::ASYNC_RESULT result);
 
    struct GxAsyncRequestCallback : public GxStructBase
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GX_RTTI_STRUCT(GxSysFile::GxAsyncRequestCallback)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GxAsyncRequestCallback(void* pUser = nullptr, REQUEST_START_CALLBACK_FUNCTION startCallback = nullptr, REQUEST_END_CALLBACK_FUNCTION endCallback = nullptr)
            : _pUser(pUser)
            , _onStartCallback(startCallback)
            , _onEndCallback(endCallback)
        {}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        void*                           _pUser;             
        REQUEST_START_CALLBACK_FUNCTION _onStartCallback;   
        REQUEST_END_CALLBACK_FUNCTION   _onEndCallback;     
 
    };
 
    struct GxAsyncRequest : public GxStructBase
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GX_RTTI_STRUCT(GxSysFile::GxAsyncRequest)
 
        
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GX_FORCE_INLINE b32 isFree(void) const { return (_pFile == nullptr); }
        constexpr void free(void) { _pFile = nullptr; _pDst = nullptr; }
        void setRequestRead(GxFile* pFile, void* pDst, u32 seek, u32 size, const GxAsyncRequestCallback* pCallback);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        GX_HANDLE                       _handle;            
        GxFile*                         _pFile;             
        void*                           _pDst;              
        u32                             _size;              
        u32                             _seek;              
        u32                             _remain;            
        REQUEST_STATE                   _state;             
        ASYNC_RESULT                    _result;            
        GxAsyncRequestCallback          _callback;          
#if GX_DEVELOP
        u32                             _requestIndex;      
#endif  // GX_DEVELOP
 
    };
 
protected:
    class GxAsyncReadThread : public GxThread
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        static constexpr s32 WAIT_INFINITY = -1;
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    public:
        void threadMain(void* pArgument) override;
 
        GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond = WAIT_INFINITY) { return _startEvent.waitEvent(milliSecond); }
        GX_FORCE_INLINE b32 setStartEvent(void) { return _startEvent.setEvent(); }
        GX_FORCE_INLINE b32 waitAsyncIOEvent(s32 milliSecond = WAIT_INFINITY) { return _asyncIOEvent.waitEvent(milliSecond); }
        GX_FORCE_INLINE b32 setAsyncIOEvent(void) { return _asyncIOEvent.setEvent(); }
 
    private:
        GX_FORCE_INLINE static void callbackAsyncRead(void* /*pUser*/, GxFile& /*file*/, u32 /*size*/) {}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
    private:
        GxEvent         _startEvent;    
        GxEvent         _asyncIOEvent;  
 
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxSysFile(void);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    b32  initialize(const GxClassBase* pInitialInformation = nullptr) override;
    void terminate(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    u32       read(GxFile* pFile, void* pDst, u32 size);
    GX_HANDLE readAsync(GxFile* pFile, void* pDst, u32 seek, u32 size, REQUEST_PRIORITY priority, const GxAsyncRequestCallback* pCallback = nullptr);
    b32       cancelAsync(GX_HANDLE requestHandle);
    b32       freeRequestHandle(GX_HANDLE requestHandle);
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    constexpr ASYNC_RESULT getAsyncResult(GX_HANDLE requestHandle) const { return _requestBuffer[requestHandle]._result; }
    constexpr GxFile* getAsyncRequestFile(GX_HANDLE requestHandle) const { return _requestBuffer[requestHandle]._pFile; }
    constexpr void* getAsyncRequestDstBuffer(GX_HANDLE requestHandle) const { return _requestBuffer[requestHandle]._pDst; }
    constexpr void setAsyncRequestDstBuffer(GX_HANDLE requestHandle, void* pDst) { _requestBuffer[requestHandle]._pDst = pDst; }
    constexpr u32 getAsyncRequestSize(GX_HANDLE requestHandle) const { return _requestBuffer[requestHandle]._size; }
    constexpr u32 getAsyncRequestRemain(GX_HANDLE requestHandle) const { return _requestBuffer[requestHandle]._remain; }
#if GX_DEVELOP
    constexpr u32 getAsyncRequestIndex(GX_HANDLE requestHandle) const { return _requestBuffer[requestHandle]._requestIndex; }
#endif  // GX_DEVELOP
 
    constexpr u32 getReserveRequestCount(REQUEST_PRIORITY priority) const { return _reserveRequestList[static_cast<s32>(priority)].getCount(); }
    u32 getFreeRequestCount(void) const;
#if GX_DEVELOP
    constexpr GxAsyncRequest* getActiveRequest(REQUEST_PRIORITY priority) const { return _pActiveRequest[static_cast<s32>(priority)]; }
    constexpr GxArray* getReserveRequestList(REQUEST_PRIORITY priority) { return &_reserveRequestList[static_cast<s32>(priority)]; }
#endif  // GX_DEVELOP
 
#if defined(_PS4)
    GX_FORCE_INLINE void setDisableStatSync(b32 flag){ _disableStatSync = flag; }
    GX_FORCE_INLINE b32 isDisableStatSync(void) const { return _disableStatSync; }
#endif //_PS4
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxAsyncRequest              _requestBuffer[REQUEST_BUFFER_MAX];             
    GxArray                     _reserveRequestList[static_cast<s32>(REQUEST_PRIORITY::MAX)];       
    GxAsyncRequest*             _pActiveRequest[static_cast<s32>(REQUEST_PRIORITY::MAX)];           
    GxAsyncReadThread           _thread;                                        
    b32                         _isStopThread;                                  
#if defined(_PS4)
    s64 _opStorage[GX_FIOS_OP_STORAGE_SIZE(GxMath::VALUE_64, GxFile::FILE_PATH_MAX) / sizeof(s64) + 1];     
    s64 _chunkStorage[GX_FIOS_CHUNK_STORAGE_SIZE(GxMath::VALUE_1K) / sizeof(s64) + 1];                      
    s64 _fHStorage[GX_FIOS_FH_STORAGE_SIZE(GxMath::VALUE_256, GxFile::FILE_PATH_MAX) / sizeof(s64) + 1];    
    s64 _dHStorage[GX_FIOS_DH_STORAGE_SIZE(GxMath::VALUE_8, GxFile::FILE_PATH_MAX) / sizeof(s64) + 1];      
#endif //_PS4
#if GX_DEVELOP
    u32                         _requestIndex;                                  
    u32                         _delayTime;                                     
#endif  // GX_DEVELOP
#if defined(_PS4)
    b32                         _disableStatSync;                               
#endif //_PS4
 
};
 
// アクセスインターフェース
GX_FORCE_INLINE GxSysFile* getGxSysFile(void){ return GxSysFile::getSingletonPointer(); }
 
//---------------------------------------------------------------------------
// 読み込みリクエスト設定
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxSysFile::GxAsyncRequest::setRequestRead(GxFile* pFile, void* pDst, u32 seek, u32 size, const GxAsyncRequestCallback* pCallback)
{
    _pFile  = pFile;
    _pDst   = pDst;
    _seek   = seek;
    _size   = _remain = size;
    _state  = REQUEST_STATE::READ;
    _result = ASYNC_RESULT::PROGRESS;
    if( pCallback )
    {
        GX_MEMCPY(&_callback, pCallback, sizeof(_callback));
    }
    else
    {
        GX_MEMSET(&_callback, 0, sizeof(_callback));
    }
}
 
GX_CORE_NAMESPACE_END()