import cProfile
import pstats
import io

def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# 기본 프로파일링 실행
def basic_profiling():
    profiler = cProfile.Profile()
    profiler.enable()
    
    # 테스트할 코드
    result = fibonacci(30)
    
    profiler.disable()
    stats = pstats.Stats(profiler).sort_stats('cumulative')
    stats.print_stats(20)  # 상위 20개 항목만 출력
    
    # 결과를 파일로 저장
    stats.dump_stats('profile.stats')
    return result

# 컨텍스트 매니저를 사용한 프로파일링
def context_manager_profiling():
    result = None
    with cProfile.Profile() as pr:
        result = fibonacci(30)
    
    s = io.StringIO()
    ps = pstats.Stats(pr, stream=s).sort_stats('tottime')
    ps.print_stats(10)
    print(s.getvalue())
    return result

# 함수 직접 프로파일링
def profile_function():
    cProfile.run('fibonacci(30)', 'profile.stats')
    # 결과 분석
    stats = pstats.Stats('profile.stats')
    stats.strip_dirs().sort_stats('cumtime').print_stats(10)

# 결과 필터링 및 시각화
def analyze_profile_results():
    stats = pstats.Stats('profile.stats')
    
    # 호출 시간이 0.1초 이상인 함수만 표시
    stats.strip_dirs().sort_stats('cumtime').print_stats(.1)
    
    # 특정 함수만 선택해서 표시
    stats.print_callers('fibonacci')
    
    # 호출자 정보 표시
    stats.print_callees('fibonacci')
    
    # 다양한 정렬 방식
    stats.sort_stats('ncalls').print_stats(5)  # 호출 횟수
    stats.sort_stats('tottime').print_stats(5)  # 순수 실행 시간
    stats.sort_stats('cumtime').print_stats(5)  # 누적 실행 시간

if __name__ == "__main__":
    basic_profiling()
    # context_manager_profiling()
    # profile_function()
    # analyze_profile_results()

# 먼저 설치: pip install line_profiler
from line_profiler import LineProfiler
import numpy as np
import time

# 프로파일링할 함수를 정의
def process_data(data):
    """대량의 데이터를 처리하는 함수"""
    result = []
    # 데이터 필터링
    filtered_data = [item for item in data if item > 0]
    
    # 데이터 변환
    for item in filtered_data:
        # 시간이 걸리는 작업 시뮬레이션
        time.sleep(0.001)
        processed = item * 2
        result.append(processed)
    
    # 결과 정렬 및 계산
    result.sort()
    total = sum(result)
    average = total / len(result) if result else 0
    
    # NumPy 사용 연산
    np_array = np.array(result)
    std_dev = np.std(np_array) if len(np_array) > 0 else 0
    
    return {
        'filtered_count': len(filtered_data),
        'result_count': len(result),
        'total': total,
        'average': average,
        'std_dev': std_dev
    }

# 함수 데코레이터 방식
@profile  # 참고: 이 데코레이터는 실행시 kernprof에 의해 인식됨
def process_with_decorator(data):
    """데코레이터로 프로파일링되는 함수"""
    return process_data(data)

# 프로그래밍 방식으로 프로파일링 설정
def manual_profiling():
    # 프로파일러 인스턴스 생성
    profiler = LineProfiler()
    
    # 프로파일링할 함수 추가
    profiler.add_function(process_data)
    
    # 테스트 데이터 생성 (일부 음수 포함)
    data = list(range(-5000, 5000))
    
    # 프로파일링 실행
    profiler.runcall(process_data, data)
    
    # 결과 출력
    profiler.print_stats(output_unit=1e-3)  # 밀리초 단위로 출력
    
    # 결과를 파일로 저장
    with open('line_profile_results.txt', 'w') as f:
        profiler.print_stats(stream=f, output_unit=1e-3)
    
    # HTML 형식으로 저장 (시각적 분석에 유용)
    profiler.dump_stats('line_profile.lprof')
    
# 여러 함수 동시 프로파일링
def multi_function_profiling():
    # 추가 함수 정의
    def helper_function(data):
        """데이터 전처리 함수"""
        return [x for x in data if isinstance(x, (int, float))]
    
    def another_function(data):
        """다른 작업을 수행하는 함수"""
        if not data:
            return []
        return [x ** 2 for x in data]
    
    # 프로파일러 설정
    profiler = LineProfiler()
    profiler.add_function(process_data)
    profiler.add_function(helper_function)
    profiler.add_function(another_function)
    
    # 실행 코드 작성
    def main_function():
        data = list(range(-100, 100))
        cleaned_data = helper_function(data)
        processed_data = process_data(cleaned_data)
        squared_data = another_function(cleaned_data)
        return processed_data, squared_data
    
    # 프로파일링 실행
    profiler.runcall(main_function)
    profiler.print_stats()

if __name__ == "__main__":
    manual_profiling()
    # multi_function_profiling()
    
    # 커맨드라인에서 실행 시:
    # python -m kernprof -l script_name.py
    # python -m line_profiler script_name.py.lprof

# 먼저 설치: pip install memory_profiler
from memory_profiler import profile
import numpy as np
import matplotlib.pyplot as plt
from functools import lru_cache
import gc
import os
import tempfile

# 라인별 메모리 사용량 측정
@profile
def memory_heavy_function():
    """메모리를 많이 사용하는 함수 예시"""
    results = []
    
    # 대용량 리스트 생성
    print("대용량 리스트 생성")
    big_list = [i for i in range(1000000)]
    results.append(sum(big_list))
    
    # 딕셔너리 생성
    print("딕셔너리 생성")
    big_dict = {i: str(i) for i in range(100000)}
    results.append(len(big_dict))
    
    # NumPy 배열 생성
    print("NumPy 배열 생성")
    big_array = np.random.random((1000, 1000))
    results.append(big_array.mean())
    
    # 중첩 리스트
    print("중첩 리스트 생성")
    nested_list = [[i for i in range(1000)] for _ in range(100)]
    results.append(sum(sum(nested_list, [])))
    
    # 문자열 조작
    print("문자열 조작")
    text = "hello" * 100000
    results.append(len(text))
    
    # 리소스 정리 (메모리 해제)
    print("리소스 정리")
    del big_list, big_dict, big_array, nested_list, text
    gc.collect()  # 가비지 컬렉션 강제 실행
    
    return results

# 메모리 누수 패턴 예제
class DataNode:
    """메모리 누수를 시연하기 위한 클래스"""
    _cache = {}  # 클래스 변수로 모든 인스턴스가 공유
    
    def __init__(self, name, data):
        self.name = name
        self.data = data
        # 자기 자신을 캐시에 저장 (메모리 누수 패턴)
        DataNode._cache[name] = self
    
    @classmethod
    def clear_cache(cls):
        cls._cache.clear()

@profile
def memory_leak_demo():
    """메모리 누수 시연"""
    # 가비지 컬렉터 설정
    gc.disable()  # 시연을 위해 가비지 컬렉션 비활성화
    
    print("1. 초기 상태")
    
    print("2. 객체 생성 시작")
    # 메모리에 지속적으로 남는 객체 생성
    for i in range(1000):
        DataNode(f"node_{i}", np.random.random((100, 100)))
    
    print("3. 명시적인 참조 제거")
    # 로컬 참조는 사라지지만 클래스 캐시에 남아있음
    
    print("4. 메모리 정리 시도")
    gc.collect()  # 수동으로 가비지 컬렉션 실행
    
    print("5. 캐시 정리")
    DataNode.clear_cache()  # 캐시 정리하여 메모리 누수 해결
    gc.collect()
    
    gc.enable()  # 가비지 컬렉터 다시 활성화
    return "완료"

# 메모리 모니터링 도구
def monitor_memory_usage(func, *args, **kwargs):
    """함수 실행 중 메모리 사용량 모니터링"""
    import time
    from memory_profiler import memory_usage
    
    # 백그라운드에서 메모리 사용량 측정
    mem_usage = []
    
    def recorder():
        # 0.1초 간격으로 메모리 사용량 기록
        mem_usage.append(memory_usage(os.getpid(), interval=0.1, timeout=1))
    
    import threading
    t = threading.Thread(target=recorder)
    t.daemon = True
    
    # 측정 시작
    t.start()
    start_time = time.time()
    result = func(*args, **kwargs)
    elapsed = time.time() - start_time
    
    # 측정 결과 가시화
    if mem_usage:
        # 평탄화
        all_measurements = [item for sublist in mem_usage for item in sublist]
        
        plt.figure(figsize=(10, 6))
        plt.plot(all_measurements)
        plt.title(f'{func.__name__} 메모리 사용량')
        plt.xlabel('시간 (0.1초 단위)')
        plt.ylabel('메모리 사용량 (MB)')
        plt.grid(True)
        plt.savefig(f'{func.__name__}_memory_profile.png')
        plt.close()
        
        print(f"최대 메모리 사용량: {max(all_measurements):.2f} MB")
        print(f"평균 메모리 사용량: {sum(all_measurements)/len(all_measurements):.2f} MB")
    
    print(f"실행 시간: {elapsed:.2f} 초")
    return result

# 대용량 파일 처리 예시
@profile
def process_large_file():
    """대용량 파일을 메모리 효율적으로 처리"""
    # 테스트용 대용량 파일 생성
    with tempfile.NamedTemporaryFile(mode='w+', delete=False) as temp_file:
        file_path = temp_file.name
        # 약 100MB 크기의 파일 생성
        for i in range(5_000_000):
            temp_file.write(f"{i},{i*2},{i*3}\n")
    
    print(f"파일 생성 완료: {file_path}")
    
    # 비효율적인 방식 (전체 파일을 메모리에 로드)
    def inefficient_read():
        print("비효율적 방식: 전체 파일 로드")
        with open(file_path, 'r') as f:
            data = f.readlines()  # 전체 파일을 메모리에 로드
        return len(data)
    
    # 효율적인 방식 (라인별 처리)
    def efficient_read():
        print("효율적 방식: 라인별 처리")
        count = 0
        total = 0
        with open(file_path, 'r') as f:
            for line in f:  # 한 번에 한 라인씩 처리
                values = line.strip().split(',')
                if values and len(values) >= 3:
                    total += int(values[2])
                count += 1
        return count, total
    
    # 두 방식의 메모리 사용량 비교
    try:
        # 비효율적 방식 실행 (주의: 메모리 부족 가능성 있음)
        # inefficient_count = inefficient_read()
        # print(f"비효율적 방식으로 읽은 라인 수: {inefficient_count}")
        
        # 효율적 방식 실행
        efficient_count, total = efficient_read()
        print(f"효율적 방식으로 읽은 라인 수: {efficient_count}, 합계: {total}")
    finally:
        # 임시 파일 삭제
        try:
            os.unlink(file_path)
            print(f"임시 파일 삭제 완료: {file_path}")
        except:
            pass
    
    return "파일 처리 완료"

if __name__ == "__main__":
    # 기본 메모리 프로파일링
    # memory_heavy_function()
    
    # 메모리 누수 시연
    # memory_leak_demo()
    
    # 메모리 모니터링
    # monitor_memory_usage(memory_heavy_function)
    
    # 대용량 파일 처리
    # process_large_file()
    
    # 다양한 방식의 메모리 프로파일링
    # python -m memory_profiler script_name.py
    pass