Tengo un bot que ejecuta un bucle que puede llegar hasta más de 2000 mil ciclos, sin embargo, este se queda paralizado hasta el ciclo 300 sin ninguna razón aparente, porque en la log de consola que hay en rocketbot, no muestra ningún mensaje de error.
Creía que era por problemas de uso de ram, pero al ejecutar el proceso con el administrador de tareas abierto, me percate que el uso de ram es constante, es decir no aumentaba y tampoco disminuía. Sin embargo, investigue que los problemas pueden ser por fragmentación de la memoria ram y que pese no llegar al 100% de uso de ram, podría suceder que la asignación de memoría si lograba llenarse y por eso se llegaba a paralizar, debido a esto le pedí la generación de un código que borrase el uso de memoria fragmentada.
El código es el siguiente:
import psutil
import gc
import subprocess
import time
import ctypes
class MemoryManager:
«»»
Clase centralizada para manejar todas las operaciones relacionadas con la memoria.
Incluye análisis de RAM, detección de fragmentación, y limpieza del sistema.
«»»
# Definimos la estructura MEMORYSTATUSEX como una clase interna
class _MEMORYSTATUSEX(ctypes.Structure):
from ctypes import wintypes, windll
_fields_ = [
(«dwLength», wintypes.DWORD),
(«dwMemoryLoad», wintypes.DWORD),
(«ullTotalPhys», ctypes.c_ulonglong),
(«ullAvailPhys», ctypes.c_ulonglong),
(«ullTotalPageFile», ctypes.c_ulonglong),
(«ullAvailPageFile», ctypes.c_ulonglong),
(«ullTotalVirtual», ctypes.c_ulonglong),
(«ullAvailVirtual», ctypes.c_ulonglong),
(«ullAvailExtendedVirtual», ctypes.c_ulonglong),
]
def __init__(self):
«»»Inicializa el gestor de memoria»»»
pass
def get_real_memory_fragmentation(self):
«»»Detecta fragmentación real usando APIs de Windows y análisis de procesos»»»
fragmentation_data = {
‘heap_fragmentation’: 0,
‘working_set_fragmentation’: 0,
‘virtual_memory_fragmentation’: 0,
‘process_memory_leaks’: [],
‘total_fragmentation_percent’: 0,
‘is_critical’: False
}
try:
# 1. Usar GlobalMemoryStatusEx para obtener información detallada
mem_status = self._MEMORYSTATUSEX()
mem_status.dwLength = ctypes.sizeof(self._MEMORYSTATUSEX)
windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(mem_status))
# 2. Calcular fragmentación basada en diferencias reales
total_phys = mem_status.ullTotalPhys
avail_phys = mem_status.ullAvailPhys
total_virtual = mem_status.ullTotalVirtual
avail_virtual = mem_status.ullAvailVirtual
# Fragmentación de memoria virtual
virtual_used = total_virtual – avail_virtual
if total_virtual > 0:
virtual_fragmentation = (virtual_used / total_virtual) * 100
fragmentation_data[‘virtual_memory_fragmentation’] = virtual_fragmentation
# 3. Análisis de procesos para detectar memory leaks reales
process_leaks = self.detect_memory_leaks()
fragmentation_data[‘process_memory_leaks’] = process_leaks
# 4. Análisis de working sets para detectar fragmentación del heap
heap_fragmentation = self.analyze_heap_fragmentation()
fragmentation_data[‘heap_fragmentation’] = heap_fragmentation
# 5. Calcular fragmentación total
total_frag = (
fragmentation_data[‘virtual_memory_fragmentation’] * 0.4 +
fragmentation_data[‘heap_fragmentation’] * 0.4 +
len(process_leaks) * 5 # Cada proceso con leak suma 5%
)
fragmentation_data[‘total_fragmentation_percent’] = min(total_frag, 95)
fragmentation_data[‘is_critical’] = total_frag > 30
return fragmentation_data
except Exception as e:
print(f»Error en análisis de fragmentación: {e}»)
return fragmentation_data
def detect_memory_leaks(self):
«»»Detecta procesos con posibles memory leaks monitoreando cambios en el tiempo»»»
leaky_processes = []
try:
# Tomar dos mediciones con un intervalo
print(«[INFO] Analizando procesos para detectar memory leaks…»)
# Primera medición
first_measurement = {}
for proc in psutil.process_iter([‘pid’, ‘name’, ‘memory_info’]):
try:
first_measurement[proc.info[‘pid’]] = {
‘name’: proc.info[‘name’],
‘memory’: proc.info[‘memory_info’].rss,
‘vms’: proc.info[‘memory_info’].vms
}
except (psutil.NoSuchProcess, psutil.AccessDenied):
continue
# Esperar un poco
time.sleep(2)
# Segunda medición
second_measurement = {}
for proc in psutil.process_iter([‘pid’, ‘name’, ‘memory_info’]):
try:
second_measurement[proc.info[‘pid’]] = {
‘name’: proc.info[‘name’],
‘memory’: proc.info[‘memory_info’].rss,
‘vms’: proc.info[‘memory_info’].vms
}
except (psutil.NoSuchProcess, psutil.AccessDenied):
continue
# Analizar cambios
for pid in first_measurement:
if pid in second_measurement:
first = first_measurement[pid]
second = second_measurement[pid]
memory_growth = second[‘memory’] – first[‘memory’]
vms_growth = second[‘vms’] – first[‘vms’]
# Detectar crecimiento anormal de memoria
if memory_growth > 10 * 1024 * 1024: # Más de 10MB en 2 segundos
leak_rate = memory_growth / (1024 * 1024) # MB/s
leaky_processes.append({
‘pid’: pid,
‘name’: first[‘name’],
‘memory_mb’: second[‘memory’] / (1024 * 1024),
‘growth_rate_mb_per_sec’: leak_rate / 2,
‘vms_growth_mb’: vms_growth / (1024 * 1024),
‘severity’: ‘HIGH’ if leak_rate > 50 else ‘MEDIUM’
})
return sorted(leaky_processes, key=lambda x: x[‘growth_rate_mb_per_sec’], reverse=True)
except Exception as e:
print(f»Error detectando memory leaks: {e}»)
return []
def analyze_heap_fragmentation(self):
«»»Analiza la fragmentación del heap usando información del sistema»»»
try:
# Usar perfmon para obtener información del heap
result = subprocess.run([
‘powershell’, ‘-Command’,
‘Get-Counter «\\Memory\\Available MBytes», «\\Memory\\Cache Bytes», «\\Memory\\Pool Nonpaged Bytes» | Select-Object -ExpandProperty CounterSamples | ForEach-Object { «$($_.Path): $($_.CookedValue)» }’
], capture_output=True, text=True, timeout=10)
if result.returncode == 0:
lines = result.stdout.strip().split(‘\n’)
available_mb = 0
cache_bytes = 0
pool_bytes = 0
for line in lines:
if ‘Available MBytes’ in line:
available_mb = float(line.split(‘:’)[1].strip())
elif ‘Cache Bytes’ in line:
cache_bytes = float(line.split(‘:’)[1].strip())
elif ‘Pool Nonpaged Bytes’ in line:
pool_bytes = float(line.split(‘:’)[1].strip())
# Calcular fragmentación estimada del heap
if available_mb > 0:
cache_ratio = (cache_bytes / (1024 * 1024)) / available_mb
pool_ratio = (pool_bytes / (1024 * 1024)) / available_mb
# Fragmentación alta si hay mucho cache/pool vs memoria disponible
heap_fragmentation = min((cache_ratio + pool_ratio) * 20, 50)
return heap_fragmentation
return 0
except Exception as e:
print(f»Error analizando heap: {e}»)
return 0
def clean_memory_advanced(self):
«»»Limpieza avanzada de memoria y desfragmentación»»»
print(«\n[LIMPIEZA] Iniciando limpieza avanzada de memoria…»)
try:
# 1. Garbage collection intensivo
print(«- Ejecutando garbage collection intensivo…»)
for i in range(5):
collected = gc.collect()
time.sleep(0.5)
print(f» [OK] Multiples ciclos completados»)
# 2. Limpiar working sets de procesos
print(«- Limpiando working sets de procesos…»)
try:
subprocess.run([
‘powershell’, ‘-Command’,
‘Get-Process | Where-Object {$_.WorkingSet -gt 50MB} | ForEach-Object { [System.GC]::Collect(); $_.Refresh() }’
], capture_output=True, timeout=15)
print(» [OK] Working sets limpiados»)
except Exception as e:
print(f» [ERROR] Error limpiando working sets: {e}»)
# 3. Compactar heap del sistema
print(«- Compactando heap del sistema…»)
try:
subprocess.run([
‘powershell’, ‘-Command’,
‘[System.Runtime.GCSettings]::LargeObjectHeapCompactionMode = [System.Runtime.GCLargeObjectHeapCompactionMode]::CompactOnce; [System.GC]::Collect()’
], capture_output=True, timeout=10)
print(» [OK] Heap compactado»)
except Exception as e:
print(f» [ERROR] Error compactando heap: {e}»)
# 4. Liberar memoria no utilizada
print(«- Liberando memoria no utilizada…»)
try:
# Usar API de Windows para liberar memoria
windll.kernel32.SetProcessWorkingSetSize(-1, -1, -1)
print(» [OK] Memoria liberada»)
except Exception as e:
print(f» [ERROR] Error liberando memoria: {e}»)
print(«[LIMPIEZA] Limpieza avanzada completada\n»)
except Exception as e:
print(f»Error en limpieza avanzada: {e}»)
def get_ram_status(self):
«»»Obtiene información detallada sobre el estado de la RAM y su fragmentación»»»
# Obtener información de la memoria RAM
memory = psutil.virtual_memory()
# Convertir bytes a GB para mejor legibilidad
total_ram = memory.total / (1024**3)
available_ram = memory.available / (1024**3)
used_ram = memory.used / (1024**3)
free_ram = memory.free / (1024**3)
# Porcentaje de uso
usage_percent = memory.percent
# Obtener fragmentación REAL
print(«[ANALISIS] Analizando fragmentacion de memoria (esto puede tomar unos segundos)…»)
fragmentation_info = self.get_real_memory_fragmentation()
print(«=» * 70)
print(«ESTADO DE LA MEMORIA RAM Y FRAGMENTACION»)
print(«=» * 70)
print(f»RAM Total: {total_ram:.2f} GB»)
print(f»RAM Usada: {used_ram:.2f} GB»)
print(f»RAM Disponible: {available_ram:.2f} GB»)
print(f»RAM Libre: {free_ram:.2f} GB»)
print(f»Porcentaje de uso: {usage_percent:.1f}%»)
# Mostrar análisis de fragmentación REAL
print(f»\n[ANALISIS] ANALISIS REAL DE FRAGMENTACION:»)
print(f»Fragmentacion del Heap: {fragmentation_info[‘heap_fragmentation’]:.1f}%»)
print(f»Fragmentacion Memoria Virtual: {fragmentation_info[‘virtual_memory_fragmentation’]:.1f}%»)
print(f»FRAGMENTACION TOTAL: {fragmentation_info[‘total_fragmentation_percent’]:.1f}%»)
# Mostrar procesos con memory leaks REALES
if fragmentation_info[‘process_memory_leaks’]:
print(f»\n[ALERTA] MEMORY LEAKS DETECTADOS:»)
for leak in fragmentation_info[‘process_memory_leaks’][:5]:
print(f» – {leak[‘name’]} (PID: {leak[‘pid’]})»)
print(f» Memoria actual: {leak[‘memory_mb’]:.1f} MB»)
print(f» Velocidad de leak: {leak[‘growth_rate_mb_per_sec’]:.2f} MB/seg»)
print(f» Severidad: {leak[‘severity’]}»)
print()
print(«=» * 70)
# Estado del sistema
if usage_percent < 50:
status = «OPTIMO»
elif usage_percent < 75:
status =»MODERADO»
elif usage_percent < 90:
status = «ALTO»
else:
status = «CRITICO»
# Estado de fragmentación
if fragmentation_info[‘is_critical’]:
frag_status = «CRITICA»
elif fragmentation_info[‘total_fragmentation_percent’] > 15:
frag_status = «ALTA»
else:
frag_status = «NORMAL»
print(f»Estado de RAM: {status}»)
print(f»Estado de Fragmentacion: {frag_status}»)
self.clean_memory_advanced()
return {
‘total’: total_ram,
‘used’: used_ram,
‘available’: available_ram,
‘free’: free_ram,
‘percent’: usage_percent,
‘status’: status,
‘fragmentation’: fragmentation_info
}
if __name__ == «__main__»:
try:
docentePosicion = GetVar(«DOCENTE_POSICION»)
docentePosicion = int(docentePosicion)
if docentePosicion % 15 == 0:
memory_manager = MemoryManager()
ram_info = memory_manager.get_ram_status()
except Exception as e:
print(f»Error al obtener informacion de RAM: {e}»)
Sin este script ejecutándose al final de cada ciclo (si es que se llego a ejecutar 15 ciclos anteriormente), el bot solo llegaba a completar entre 17-42 ciclos, lo cual es muy bajo a comparación de con este, pero el problema es que pese esta optimización no se logra completar los 1200 ciclos que tengo (en otros casos pueden ser más de 2000) y solo se queda hasta 300 (específicamente 349).
Adjunto imágenes para que puedan ver los procesos del bot
Se ha omitido la captura de algunos procesos porque son lo mismo que los anteriores y lo único que cambia son la declaración de variables. Además como se puede apreciar se ha desactivado la declaración de variables y se ha cambiado por la alternativa de declararlo con código python, esto es porque con declaración de variables solo llegaba a 80-120 ciclos.
Muestro una captura de log de consola.
¿Alguien ha pasado por un problema similar? Si es así, ¿Cómo lo lograron solucionar? ¿Saben por qué realmente sucede esto? Gracias por su tiempo.
Buen día Roberto. Esto le sucede en desarrollo o en producción?
Si es en desarrollo, le comento que Studio está pensado para ejecutar pruebas en dicho entorno, no para ejecutar procesos por tanto tiempo como si estuviese en producción.
Si cuenta con una licencia de producción, pruebe una ejecución allí para verificar el comportamiento. Quedamos atentos!
Un cordial saludo.
Quiero notificar que pase de utilizar for a while, el proceso va algo más rápido, pero ahora dura muchísimo menos, siendo posible que la razón del problema sea por el propio software de rocketbot a que por otros temas como la licencia, teniendo en cuenta que tengo otros botos que demoran más de 9 horas de proceso y si logran terminar todo el ciclo, estos bots incluso tienen más procesos, pero tienen como un delay establecido de manera manual.
Puede que para mejorar la consistencia del bot actual presentado, se utilice tiempos de espera colocado apropósito, sin embargo, los planes de rocketbot establecen horas máximas de ejecución por lo que no sería una respuesta aceptable, ya que necesito completar el proceso lo más rápido posible para evitar llegar a ese limite, pero el software de rocketbot no puede ejecutarse de manera normal sin delays, porque por un tema de memoria no es posible de completar todo el proceso y se queda congelado.
Un cordial saludo.
Estoy volviendo a realizar la adquisición de Rocketbot, sin embargo, quiero notificar que este problema que menciono no me sucedía con otros Bots ejecutados en modo prueba, los cuales llegaban a demorar más de 9 horas de proceso y tenían mayor consumo de memoria ram, en este caso son 3 horas de proceso en el cual se congela y el consumo de ram es mucho menor.