403 lines
13 KiB
MQL5
403 lines
13 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| CResourceManager.mqh - Automated Resource Lifecycle Management |
| |||
//| Handles: indicator handles, file handles, memory allocations |
| |||
//+------------------------------------------------------------------+
| |||
#ifndef CRESOURCE_MANAGER_MQH
| |||
#define CRESOURCE_MANAGER_MQH
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Resource Types |
| |||
//+------------------------------------------------------------------+
| |||
enum ENUM_RESOURCE_TYPE
| |||
{
| |||
RES_INDICATOR_HANDLE = 0, // iMA, iRSI, etc. handles
| |||
RES_FILE_HANDLE = 1, // FileOpen handles
| |||
RES_DYNAMIC_ARRAY = 2, // Dynamically allocated arrays
| |||
RES_OBJECT_PTR = 3, // CObject pointers
| |||
RES_NETWORK_HANDLE = 4 // Socket/HTTP handles
| |||
};
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Resource Entry Structure |
| |||
//+------------------------------------------------------------------+
| |||
struct SResourceEntry
| |||
{
| |||
long resource_id; // Handle or pointer value
| |||
ENUM_RESOURCE_TYPE type; // Resource type
| |||
string owner; // Component that allocated it
| |||
string description; // Human-readable description
| |||
datetime alloc_time; // When it was allocated
| |||
int alloc_line; // Line number in source
| |||
string alloc_file; // Source file
| |||
| |||
void Set(long id, ENUM_RESOURCE_TYPE t, const string own,
| |||
const string desc, const string file, int line)
| |||
{
| |||
resource_id = id;
| |||
type = t;
| |||
owner = own;
| |||
description = desc;
| |||
alloc_time = TimeCurrent();
| |||
alloc_line = line;
| |||
alloc_file = file;
| |||
}
| |||
| |||
bool IsValid() { return resource_id != 0; }
| |||
| |||
void Clear()
| |||
{
| |||
resource_id = 0;
| |||
type = RES_INDICATOR_HANDLE;
| |||
owner = "";
| |||
description = "";
| |||
alloc_time = 0;
| |||
alloc_line = 0;
| |||
alloc_file = "";
| |||
}
| |||
};
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Resource Manager Class |
| |||
//+------------------------------------------------------------------+
| |||
class CResourceManager
| |||
{
| |||
private:
| |||
SResourceEntry m_resources[];
| |||
int m_capacity;
| |||
int m_count;
| |||
| |||
// Statistics
| |||
int m_total_allocated[5];
| |||
int m_total_released[5];
| |||
int m_leak_detected[5];
| |||
| |||
public:
| |||
CResourceManager()
| |||
{
| |||
m_capacity = 256;
| |||
m_count = 0;
| |||
ArrayResize(m_resources, m_capacity);
| |||
| |||
for(int i = 0; i < 5; i++)
| |||
{
| |||
m_total_allocated[i] = 0;
| |||
m_total_released[i] = 0;
| |||
m_leak_detected[i] = 0;
| |||
}
| |||
}
| |||
| |||
~CResourceManager()
| |||
{
| |||
CleanupAllResources();
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Track indicator handle |
| |||
//+------------------------------------------------------------------+
| |||
void TrackIndicator(int handle, const string owner, const string description,
| |||
const string file, int line)
| |||
{
| |||
if(handle == INVALID_HANDLE) return;
| |||
| |||
int idx = FindFreeSlot();
| |||
if(idx >= 0)
| |||
{
| |||
m_resources[idx].Set(handle, RES_INDICATOR_HANDLE, owner,
| |||
description, file, line);
| |||
m_total_allocated[RES_INDICATOR_HANDLE]++;
| |||
m_count++;
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Track file handle |
| |||
//+------------------------------------------------------------------+
| |||
void TrackFile(int handle, const string owner, const string description,
| |||
const string file, int line)
| |||
{
| |||
if(handle == INVALID_HANDLE) return;
| |||
| |||
int idx = FindFreeSlot();
| |||
if(idx >= 0)
| |||
{
| |||
m_resources[idx].Set(handle, RES_FILE_HANDLE, owner,
| |||
description, file, line);
| |||
m_total_allocated[RES_FILE_HANDLE]++;
| |||
m_count++;
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Release indicator handle |
| |||
//+------------------------------------------------------------------+
| |||
bool ReleaseIndicator(int handle, const string owner)
| |||
{
| |||
if(handle == INVALID_HANDLE) return true;
| |||
| |||
int idx = FindResource(handle, RES_INDICATOR_HANDLE, owner);
| |||
if(idx >= 0)
| |||
{
| |||
// Actually release the indicator
| |||
bool released = IndicatorRelease((int)m_resources[idx].resource_id);
| |||
| |||
m_resources[idx].Clear();
| |||
m_total_released[RES_INDICATOR_HANDLE]++;
| |||
m_count--;
| |||
return released;
| |||
}
| |||
| |||
// Not tracked - try to release anyway
| |||
return IndicatorRelease(handle);
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Release file handle |
| |||
//+------------------------------------------------------------------+
| |||
bool ReleaseFile(int handle, const string owner)
| |||
{
| |||
if(handle == INVALID_HANDLE) return true;
| |||
| |||
int idx = FindResource(handle, RES_FILE_HANDLE, owner);
| |||
if(idx >= 0)
| |||
{
| |||
// Actually close the file
| |||
FileClose((int)m_resources[idx].resource_id);
| |||
| |||
m_resources[idx].Clear();
| |||
m_total_released[RES_FILE_HANDLE]++;
| |||
m_count--;
| |||
return true;
| |||
}
| |||
| |||
// Not tracked - try to close anyway
| |||
FileClose(handle);
| |||
return true;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Release all resources for an owner |
| |||
//+------------------------------------------------------------------+
| |||
int ReleaseAllForOwner(const string owner)
| |||
{
| |||
int released = 0;
| |||
for(int i = 0; i < m_capacity; i++)
| |||
{
| |||
if(m_resources[i].IsValid() && m_resources[i].owner == owner)
| |||
{
| |||
switch(m_resources[i].type)
| |||
{
| |||
case RES_INDICATOR_HANDLE:
| |||
IndicatorRelease((int)m_resources[i].resource_id);
| |||
break;
| |||
case RES_FILE_HANDLE:
| |||
FileClose((int)m_resources[i].resource_id);
| |||
break;
| |||
}
| |||
| |||
m_total_released[m_resources[i].type]++;
| |||
m_resources[i].Clear();
| |||
released++;
| |||
m_count--;
| |||
}
| |||
}
| |||
return released;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Cleanup all resources (emergency cleanup) |
| |||
//+------------------------------------------------------------------+
| |||
void CleanupAllResources()
| |||
{
| |||
for(int i = 0; i < m_capacity; i++)
| |||
{
| |||
if(m_resources[i].IsValid())
| |||
{
| |||
switch(m_resources[i].type)
| |||
{
| |||
case RES_INDICATOR_HANDLE:
| |||
IndicatorRelease((int)m_resources[i].resource_id);
| |||
m_total_released[RES_INDICATOR_HANDLE]++;
| |||
break;
| |||
case RES_FILE_HANDLE:
| |||
FileClose((int)m_resources[i].resource_id);
| |||
m_total_released[RES_FILE_HANDLE]++;
| |||
break;
| |||
}
| |||
| |||
m_resources[i].Clear();
| |||
m_count--;
| |||
}
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Get leak report |
| |||
//+------------------------------------------------------------------+
| |||
string GetLeakReport()
| |||
{
| |||
string report = "=== Resource Leak Report ===\n";
| |||
| |||
// Calculate leaks per type
| |||
for(int type = 0; type < 5; type++)
| |||
{
| |||
int leaked = m_total_allocated[type] - m_total_released[type];
| |||
if(leaked > 0)
| |||
{
| |||
m_leak_detected[type] = leaked;
| |||
report += StringFormat(" %s: %d leaks detected\n",
| |||
TypeToString(type), leaked);
| |||
}
| |||
}
| |||
| |||
// Show active resources
| |||
if(m_count > 0)
| |||
{
| |||
report += StringFormat("\nActive Resources (%d total):\n", m_count);
| |||
for(int i = 0; i < m_capacity; i++)
| |||
{
| |||
if(m_resources[i].IsValid())
| |||
{
| |||
report += StringFormat(" [%s] %s: %s (owner: %s, file: %s:%d)\n",
| |||
TypeToString(m_resources[i].type),
| |||
m_resources[i].resource_id,
| |||
m_resources[i].description,
| |||
m_resources[i].owner,
| |||
m_resources[i].alloc_file,
| |||
m_resources[i].alloc_line);
| |||
}
| |||
}
| |||
}
| |||
| |||
return report;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Get statistics |
| |||
//+------------------------------------------------------------------+
| |||
string GetStatistics()
| |||
{
| |||
string stats = "=== Resource Statistics ===\n";
| |||
| |||
for(int type = 0; type < 5; type++)
| |||
{
| |||
if(m_total_allocated[type] > 0)
| |||
{
| |||
int leaked = m_total_allocated[type] - m_total_released[type];
| |||
stats += StringFormat("%s: Alloc=%d, Rel=%d, Leaked=%d\n",
| |||
TypeToString(type),
| |||
m_total_allocated[type],
| |||
m_total_released[type],
| |||
leaked);
| |||
}
| |||
}
| |||
| |||
stats += StringFormat("\nCurrent Active: %d\n", m_count);
| |||
return stats;
| |||
}
| |||
| |||
private:
| |||
int FindFreeSlot()
| |||
{
| |||
for(int i = 0; i < m_capacity; i++)
| |||
{
| |||
if(!m_resources[i].IsValid())
| |||
return i;
| |||
}
| |||
| |||
// No free slots - expand array
| |||
int old_capacity = m_capacity;
| |||
m_capacity += 64;
| |||
ArrayResize(m_resources, m_capacity);
| |||
| |||
return old_capacity; // Return first new slot
| |||
}
| |||
| |||
int FindResource(long id, ENUM_RESOURCE_TYPE type, const string owner)
| |||
{
| |||
for(int i = 0; i < m_capacity; i++)
| |||
{
| |||
if(m_resources[i].IsValid() &&
| |||
m_resources[i].resource_id == id &&
| |||
m_resources[i].type == type &&
| |||
(owner == "" || m_resources[i].owner == owner))
| |||
{
| |||
return i;
| |||
}
| |||
}
| |||
return -1;
| |||
}
| |||
| |||
static string TypeToString(int type)
| |||
{
| |||
switch(type)
| |||
{
| |||
case RES_INDICATOR_HANDLE: return "INDICATOR";
| |||
case RES_FILE_HANDLE: return "FILE";
| |||
case RES_DYNAMIC_ARRAY: return "ARRAY";
| |||
case RES_OBJECT_PTR: return "OBJECT";
| |||
case RES_NETWORK_HANDLE: return "NETWORK";
| |||
}
| |||
return "UNKNOWN";
| |||
}
| |||
};
| |||
| |||
// Global resource manager
| |||
CResourceManager* g_resource_manager = NULL;
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize resource management |
| |||
//+------------------------------------------------------------------+
| |||
bool InitializeResourceManager()
| |||
{
| |||
if(g_resource_manager != NULL)
| |||
delete g_resource_manager;
| |||
| |||
g_resource_manager = new CResourceManager();
| |||
Print("[ResourceManager] Initialized");
| |||
return true;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Shutdown resource management |
| |||
//+------------------------------------------------------------------+
| |||
void ShutdownResourceManager()
| |||
{
| |||
if(g_resource_manager != NULL)
| |||
{
| |||
Print(g_resource_manager.GetStatistics());
| |||
Print(g_resource_manager.GetLeakReport());
| |||
| |||
// Cleanup any remaining resources
| |||
g_resource_manager.CleanupAllResources();
| |||
| |||
delete g_resource_manager;
| |||
g_resource_manager = NULL;
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Convenience macros for resource tracking |
| |||
//+------------------------------------------------------------------+
| |||
#define TRACK_INDICATOR(handle, desc) \
| |||
do { if(g_resource_manager != NULL && handle != INVALID_HANDLE) \
| |||
g_resource_manager.TrackIndicator(handle, __FILE__, desc, __FILE__, __LINE__); } while(0)
| |||
| |||
#define RELEASE_INDICATOR(handle) \
| |||
do { if(g_resource_manager != NULL) \
| |||
g_resource_manager.ReleaseIndicator(handle, __FILE__); \
| |||
else if(handle != INVALID_HANDLE) IndicatorRelease(handle); } while(0)
| |||
| |||
#define TRACK_FILE(handle, desc) \
| |||
do { if(g_resource_manager != NULL && handle != INVALID_HANDLE) \
| |||
g_resource_manager.TrackFile(handle, __FILE__, desc, __FILE__, __LINE__); } while(0)
| |||
| |||
#define RELEASE_FILE(handle) \
| |||
do { if(g_resource_manager != NULL) \
| |||
g_resource_manager.ReleaseFile(handle, __FILE__); \
| |||
else if(handle != INVALID_HANDLE) FileClose(handle); } while(0)
| |||
| |||
#define RELEASE_ALL_FOR_OWNER(owner) \
| |||
do { if(g_resource_manager != NULL) \
| |||
g_resource_manager.ReleaseAllForOwner(owner); } while(0)
| |||
| |||
#endif // CRESOURCE_MANAGER_MQH
|