업로드 실패알람 조건 변경

LYW

2022-08-05 5f12658f37fed156e67b3318542c98f359341ffd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#pragma once
 
#include <assert.h>
 
// Edited from C8MemPool class (Hitel, gma 7 3) - 1CoinClear -
 
template<class Type> class CMemPooler
{
public:
    // »ý¼ºÀÚ 
    CMemPooler(int nNumOfBlock):m_nNumofBlock(nNumOfBlock),
                               m_pFreeList(NULL),
                               m_pMemBlock(NULL),
                               m_nAllocCount(0)
    {
        assert(nNumOfBlock > 0);
        m_nListBlockSize = sizeof(BlockNode) + sizeof(Type);
        
        Create();
    }
 
    // ¼Ò¸êÀÚ
    ~CMemPooler()
    {
        Destroy();
    }
 
    // ¸Þ¸ð¸® ÇÒ´ç 
    Type* Alloc()
    {
        EnterCriticalSection(&m_csAlloc);
 
        BlockNode* pNode = NULL;
        Type* pRet = NULL;
 
        ////////////////////////////
        pNode = m_pFreeList;
        if(pNode != NULL)
        {
            m_pFreeList = m_pFreeList->pNext;
            m_nAllocCount++;
            pRet = reinterpret_cast<Type*>(pNode+1);
        }
 
        ////////////////////////////
        LeaveCriticalSection(&m_csAlloc);
 
        return pRet;
    }
 
    BOOL Free(Type* freeBlock)
    {
        EnterCriticalSection(&m_csAlloc);
 
        BlockNode* pNode = NULL;
        BOOL bRet = FALSE;
 
        ///////////////////////////
 
        pNode = (reinterpret_cast<BlockNode*>(freeBlock)) - 1;
        if(m_nAllocCount > 0)
        {
            pNode->pNext = m_pFreeList;
            m_pFreeList = pNode;
            m_nAllocCount--;
            bRet = TRUE;
        }
 
        ///////////////////////////
        LeaveCriticalSection(&m_csAlloc);
 
        return bRet;
    }
 
    int GetAllocCount()
    {
        return m_nAllocCount;
    }
    int GetBlockCount()
    {
        return m_nNumofBlock;
    }
 
protected:
    void Create()
    {
        const int AllocationSize = (m_nListBlockSize) * m_nNumofBlock; // ¸Þ¸ð¸® ÇÒ´çÇÒ Å©±â 
        m_pMemBlock = VirtualAlloc(NULL, AllocationSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
        assert(m_pMemBlock);
 
        BlockNode* pNode = reinterpret_cast<BlockNode*>(m_pMemBlock);
 
        //pNode = reinterpret_cast<BlockNode*>((reinterpret_cast<DWORD>(pNode))+(m_nNumofBlock-1)* (m_nListBlockSize) );
        pNode = (BlockNode*)((char*)pNode + ((m_nNumofBlock - 1) * (m_nListBlockSize)));
        for(int i = m_nNumofBlock - 1; i >= 0; i--)
        {
            pNode->pNext = m_pFreeList; // Ã³À½¿¡´Â NULL , Áï Tail Àº NULL ·Î ÇÑ´Ù.
            m_pFreeList = pNode;
            //pNode = reinterpret_cast<BlockNode*>((reinterpret_cast<DWORD>(pNode))-m_nListBlockSize);
            pNode = (BlockNode*)((char*)pNode - m_nListBlockSize);
        }
 
        InitializeCriticalSection(&m_csAlloc);
    }
 
    void Destroy()
    {
        if(m_pMemBlock)
        {
            VirtualFree(m_pMemBlock,0,MEM_RELEASE);
        }
 
        DeleteCriticalSection(&m_csAlloc);
    }
 
    ///////////////////////////////////////////
    // ¸µÅ©µå ¸®½ºÆ® Ã³·³ °ü¸®¸¦ À§ÇÑ ³ëµå Å¸ÀÔ
    struct BlockNode
    {
        BlockNode* pNext;
        BlockNode()
        {
            pNext=NULL;
        }
    };
    //////////////////////////////////////////
 
protected:
    BlockNode* m_pFreeList; // ³²¾Æ Àִ ¸Þ¸ð¸® ºí·° ¸®½ºÆ®
    void* m_pMemBlock;
 
    int m_nNumofBlock;      // ¸Þ¸ð¸® ÇÒ´çÇÒ ºí·° ¼ö
    int m_nListBlockSize;   // ÇÑ ºí·° »çÀÌÁî 
    int m_nAllocCount;      // ÇÒ´çµÈ ¸Þ¸ð¸® ºí·° °¹¼ö
 
    CRITICAL_SECTION m_csAlloc;  // For Thread-Safe;
};