cal.py

#!/usr/bin/env python3
"""
GPU内存占用程序
占用指定CUDA设备的显存
"""

import torch
import time
import gc
import argparse
import signal
import sys
import random
import math
from typing import List


class GPUMemoryOccupier:
    def __init__(self, device_ids: List[int] = [2], memory_gb: float = 18.0):
        """
        初始化GPU内存占用器
        
        Args:
            device_ids: CUDA设备ID列表，默认为[2]
            memory_gb: 每个设备要占用的显存大小(GB)，默认为18GB
        """
        self.device_ids = device_ids if isinstance(device_ids, list) else [device_ids]
        self.memory_gb = memory_gb
        self.allocated_tensors: dict = {device_id: [] for device_id in self.device_ids}
        self.computation_tensors: dict = {device_id: [] for device_id in self.device_ids}
        self.running = True
        
        # 检查CUDA是否可用
        if not torch.cuda.is_available():
            raise RuntimeError("CUDA不可用，请检查CUDA环境配置")
        
        # 检查所有设备是否存在
        available_devices = torch.cuda.device_count()
        for device_id in self.device_ids:
            if device_id >= available_devices:
                raise RuntimeError(f"CUDA设备{device_id}不存在，当前可用设备数量: {available_devices}")
        
        print(f"目标设备: {self.device_ids}")
        for device_id in self.device_ids:
            print(f"设备{device_id}: {torch.cuda.get_device_name(device_id)}")
        
    def get_available_memory(self, device_id: int) -> float:
        """获取指定设备的可用显存(GB)"""
        torch.cuda.set_device(device_id)
        total_memory = torch.cuda.get_device_properties(device_id).total_memory
        allocated_memory = torch.cuda.memory_allocated(device_id)
        available_memory = total_memory - allocated_memory
        return available_memory / (1024**3)  # 转换为GB
    
    def get_total_memory(self, device_id: int) -> float:
        """获取指定设备的总显存(GB)"""
        torch.cuda.set_device(device_id)
        total_memory = torch.cuda.get_device_properties(device_id).total_memory
        return total_memory / (1024**3)  # 转换为GB
    
    def get_allocated_memory(self, device_id: int) -> float:
        """获取指定设备已分配的显存(GB)"""
        torch.cuda.set_device(device_id)
        allocated_memory = torch.cuda.memory_allocated(device_id)
        return allocated_memory / (1024**3)  # 转换为GB
    
    def get_all_memory_info(self) -> dict:
        """获取所有设备的显存信息"""
        memory_info = {}
        for device_id in self.device_ids:
            memory_info[device_id] = {
                'total': self.get_total_memory(device_id),
                'allocated': self.get_allocated_memory(device_id),
                'available': self.get_available_memory(device_id)
            }
        return memory_info
    
    def create_computation_tensors(self, device_id: int):
        """为计算创建专门的张量"""
        torch.cuda.set_device(device_id)
        
        # 创建用于计算的张量 - 这些会持续产生GPU负载
        sizes = [
            (1024, 1024),    # 小型矩阵
            (2048, 2048),    # 中型矩阵  
            (4096, 4096),    # 大型矩阵
            (8192, 8192),    # 超大型矩阵
        ]
        
        for size in sizes:
            try:
                # 创建随机矩阵
                tensor = torch.randn(size, dtype=torch.float32, device=f"cuda:{device_id}")
                self.computation_tensors[device_id].append(tensor)
            except Exception:
                # 如果创建失败，跳过这个尺寸
                continue
    
    def perform_gpu_computation(self, device_id: int):
        """执行真正的GPU计算来产生使用率"""
        torch.cuda.set_device(device_id)
        
        if not self.computation_tensors[device_id]:
            return
        
        try:
            # 选择随机计算类型
            computation_type = random.choice([
                'matrix_multiply', 'convolution', 'reduction', 
                'element_wise', 'transpose_ops', 'mixed_operations'
            ])
            
            if computation_type == 'matrix_multiply':
                # 矩阵乘法 - 高计算强度
                a = random.choice(self.computation_tensors[device_id])
                b = random.choice(self.computation_tensors[device_id])
                if a.size(1) == b.size(0):
                    for _ in range(10):  # 重复多次增加计算量
                        result = torch.matmul(a, b)
                        # 使用结果避免被优化掉
                        result = result * 0.99 + 0.01
                        torch.cuda.synchronize(device_id)
            
            elif computation_type == 'convolution':
                # 卷积-like 操作
                tensor = random.choice(self.computation_tensors[device_id])
                if tensor.dim() == 2:
                    # 添加批次和通道维度
                    tensor_4d = tensor.unsqueeze(0).unsqueeze(0)
                    # 创建卷积核
                    kernel = torch.randn(3, 3, 3, 3, device=f'cuda:{device_id}') * 0.1
                    for _ in range(5):
                        result = torch.nn.functional.conv2d(tensor_4d, kernel, padding=1)
                        result = torch.relu(result)
                        torch.cuda.synchronize(device_id)
            
            elif computation_type == 'reduction':
                # 归约操作
                tensor = random.choice(self.computation_tensors[device_id])
                for _ in range(20):
                    result = tensor.sum() + tensor.mean() + tensor.std() + tensor.max() + tensor.min()
                    # 确保结果被使用
                    result = result * 0.0001
                    torch.cuda.synchronize(device_id)
            
            elif computation_type == 'element_wise':
                # 元素级操作
                tensor = random.choice(self.computation_tensors[device_id])
                for _ in range(15):
                    result = torch.sigmoid(tensor) * torch.tanh(tensor) + torch.relu(tensor * 0.5)
                    result = torch.log(torch.abs(result) + 1.0)
                    torch.cuda.synchronize(device_id)
            
            elif computation_type == 'transpose_ops':
                # 转置和重排操作
                tensor = random.choice(self.computation_tensors[device_id])
                for _ in range(8):
                    result = tensor.T
                    result = result.contiguous()
                    result = torch.matmul(result, tensor)
                    torch.cuda.synchronize(device_id)
            
            elif computation_type == 'mixed_operations':
                # 混合操作
                a = random.choice(self.computation_tensors[device_id])
                b = random.choice(self.computation_tensors[device_id])
                for _ in range(12):
                    result1 = torch.matmul(a, b)
                    result2 = torch.sigmoid(a) * torch.tanh(b)
                    result3 = result1 + result2
                    result3 = torch.relu(result3)
                    torch.cuda.synchronize(device_id)
                    
        except Exception as e:
            # 忽略计算错误，继续运行
            pass
    
    def allocate_memory_single_device(self, device_id: int):
        """为单个设备分配指定大小的显存"""
        torch.cuda.set_device(device_id)
        
        total_memory = self.get_total_memory(device_id)
        available_memory = self.get_available_memory(device_id)
        
        print(f"\n设备 {device_id}:")
        print(f"  总显存: {total_memory:.2f} GB")
        print(f"  可用显存: {available_memory:.2f} GB")
        print(f"  目标占用显存: {self.memory_gb:.2f} GB")
        
        if self.memory_gb > available_memory:
            print(f"  警告: 目标占用显存 ({self.memory_gb:.2f} GB) 大于可用显存 ({available_memory:.2f} GB)")
            print(f"  将尝试占用最大可用显存: {available_memory * 0.95:.2f} GB")
            target_memory = available_memory * 0.95
        else:
            target_memory = self.memory_gb
        
        # 计算需要分配的字节数
        bytes_to_allocate = int(target_memory * 1024**3)
        
        # 分配内存，使用float32数据类型 (每个元素4字节)
        elements_needed = bytes_to_allocate // 4
        
        try:
            print(f"  正在分配 {target_memory:.2f} GB 显存...")
            
            # 分块分配，避免单个张量过大
            chunk_size = min(elements_needed, 500_000_000)  # 每块最多2GB
            
            while elements_needed > 0:
                current_chunk = min(chunk_size, elements_needed)
                tensor = torch.randn(current_chunk, dtype=torch.float32, device=f"cuda:{device_id}")
                self.allocated_tensors[device_id].append(tensor)
                elements_needed -= current_chunk
                
                # 实时显示分配进度
                current_allocated = self.get_allocated_memory(device_id)
                print(f"  已分配显存: {current_allocated:.2f} GB", end='\r')
            
            print(f"\n  成功分配显存: {self.get_allocated_memory(device_id):.2f} GB")
            
            # 创建计算张量
            print("  创建计算张量...")
            self.create_computation_tensors(device_id)
            
        except torch.cuda.OutOfMemoryError as e:
            print(f"\n  显存不足错误: {e}")
            print(f"  当前已分配: {self.get_allocated_memory(device_id):.2f} GB")
            raise
        except Exception as e:
            print(f"\n  分配过程中发生错误: {e}")
            raise
    
    def allocate_memory(self):
        """为所有指定设备分配显存"""
        print("开始为所有设备分配显存...")
        
        for device_id in self.device_ids:
            try:
                self.allocate_memory_single_device(device_id)
            except Exception as e:
                print(f"设备 {device_id} 分配失败: {e}")
                # 继续为其他设备分配
                continue
        
        print(f"\n所有设备显存分配完成！")
        self._print_summary()
    
    def _print_summary(self):
        """打印显存使用摘要"""
        print("\n=== 显存使用摘要 ===")
        total_allocated = 0
        for device_id in self.device_ids:
            allocated = self.get_allocated_memory(device_id)
            total = self.get_total_memory(device_id)
            usage_percent = (allocated / total) * 100
            print(f"设备 {device_id}: {allocated:.2f}GB / {total:.2f}GB ({usage_percent:.1f}%)")
            total_allocated += allocated
        print(f"总占用显存: {total_allocated:.2f} GB")
        print("=" * 20)
    
    def free_memory(self):
        """释放所有分配的显存"""
        print("正在释放所有设备的显存...")
        self.running = False
        for device_id in self.device_ids:
            self.allocated_tensors[device_id].clear()
            self.computation_tensors[device_id].clear()
            torch.cuda.set_device(device_id)
            torch.cuda.empty_cache()
            print(f"设备 {device_id} 显存已释放")
        
        gc.collect()
        print("所有显存释放完成")
        self._print_summary()
    
    def start_computation_loop(self, device_id: int):
        """启动计算循环来持续产生GPU使用率"""
        def computation_worker():
            torch.cuda.set_device(device_id)
            while self.running:
                if random.random() < 0.8:  # 80%的概率执行计算
                    self.perform_gpu_computation(device_id)
                time.sleep(0.1)  # 短暂休息
        
        import threading
        thread = threading.Thread(target=computation_worker, daemon=True)
        thread.start()
        return thread
    
    def monitor_memory(self, interval: int = 5):
        """监控所有设备的显存使用情况"""
        print(f"\n开始监控所有设备显存使用情况 (每{interval}秒更新一次)")
        print("启动计算线程来产生GPU使用率...")
        print("按 Ctrl+C 停止监控并释放显存")
        
        # 启动计算线程
        computation_threads = []
        for device_id in self.device_ids:
            thread = self.start_computation_loop(device_id)
            computation_threads.append(thread)
            print(f"设备 {device_id} 计算线程已启动")
        
        try:
            while True:
                print(f"\n[{time.strftime('%H:%M:%S')}] 显存状态:")
                total_allocated = 0
                total_memory = 0
                
                for device_id in self.device_ids:
                    allocated = self.get_allocated_memory(device_id)
                    available = self.get_available_memory(device_id)
                    total = self.get_total_memory(device_id)
                    usage_percent = (allocated / total) * 100
                    
                    print(f"  GPU {device_id}: {allocated:.2f}GB / {total:.2f}GB "
                          f"({usage_percent:.1f}%) | 可用: {available:.2f}GB")
                    
                    total_allocated += allocated
                    total_memory += total
                
                overall_usage = (total_allocated / total_memory) * 100 if total_memory > 0 else 0
                print(f"  总计: {total_allocated:.2f}GB / {total_memory:.2f}GB ({overall_usage:.1f}%)")
                print("  GPU计算线程正在运行中...")
                
                time.sleep(interval)
                
        except KeyboardInterrupt:
            print("\n接收到停止信号，正在清理...")
            self.free_memory()
            sys.exit(0)


def signal_handler(signum, frame):
    """信号处理函数"""
    print(f"\n接收到信号 {signum}，正在清理...")
    sys.exit(0)


def parse_device_list(device_str: str) -> List[int]:
    """解析设备列表字符串，支持格式: "1", "1,2,3", "1-3"等"""
    devices = []
    parts = device_str.split(',')
    
    for part in parts:
        part = part.strip()
        if '-' in part:
            # 处理范围，如"1-3"
            start, end = map(int, part.split('-'))
            devices.extend(range(start, end + 1))
        else:
            # 处理单个设备
            devices.append(int(part))
    
    return sorted(list(set(devices)))  # 去重并排序


def main():
    parser = argparse.ArgumentParser(description="GPU显存占用工具")
    parser.add_argument("--devices", "-d", type=str, default="0", 
                        help="CUDA设备ID，支持多种格式: 单个设备(2)，多个设备(1,2,3)，范围(1-3) (默认: 2)")
    parser.add_argument("--memory", "-m", type=float, default=8.0,
                        help="每个设备要占用的显存大小(GB) (默认: 18.0)")
    parser.add_argument("--monitor", action="store_true",
                        help="持续监控显存使用情况")
    parser.add_argument("--interval", "-i", type=int, default=5,
                        help="监控间隔时间(秒) (默认: 5)")
    
    args = parser.parse_args()
    
    # 解析设备列表
    try:
        device_ids = parse_device_list(args.devices)
    except ValueError as e:
        print(f"设备ID解析错误: {e}")
        print("请使用正确的格式，例如: 2 或 1,2,3 或 1-3")
        sys.exit(1)
    
    print(f"将要占用的设备: {device_ids}")
    print(f"每个设备占用显存: {args.memory} GB")
    
    # 设置信号处理
    signal.signal(signal.SIGINT, signal_handler)
    signal.signal(signal.SIGTERM, signal_handler)
    
    try:
        # 创建显存占用器
        occupier = GPUMemoryOccupier(device_ids=device_ids, memory_gb=args.memory)
        
        # 分配显存
        occupier.allocate_memory()
        
        if args.monitor:
            # 开始监控
            occupier.monitor_memory(interval=args.interval)
        else:
            print("\n显存分配完成！")
            print("启动计算线程来产生GPU使用率...")
            print("按 Ctrl+C 停止程序并释放显存。")
            
            # 启动计算线程
            computation_threads = []
            for device_id in device_ids:
                thread = occupier.start_computation_loop(device_id)
                computation_threads.append(thread)
                print(f"设备 {device_id} 计算线程已启动")
            
            try:
                while True:
                    time.sleep(1)
            except KeyboardInterrupt:
                print("\n正在释放显存...")
                occupier.free_memory()
                print("程序结束。")
    
    except Exception as e:
        print(f"程序执行出错: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()