Update decorators_gokay_sahin.py

Author: katex35

Week04/decorators_gokay_sahin.py

@@ -1,52 +1,40 @@
 import time
-import psutil
-
-total_time = 0
-total_mem = 0
-counter = 0
+import tracemalloc
 
 def performance(fn):
     """
-    A decorator function to measure the performance of a given function by tracking 
-    both its execution time and memory usage. 
-
-    This decorator calculates the time taken for the function to run and the 
-    memory used before and after its execution. It also maintains a global counter 
-    of how many times the decorated function has been called, along with 
-    accumulating the total time and memory usage.
-
-    :param fn: Function to be decorated and monitored.
-    :type fn: Callable
-    :return: A wrapper function that monitors performance of the original function.
-    :rtype: Callable
-    
-    Global Variables:
-    - **total_time** (float): Accumulates the total execution time across all invocations.
-    - **total_mem** (int): Accumulates the total memory difference across all invocations.
-    - **counter** (int): Tracks how many times the decorated function has been executed.
-    
-    Example usage::
-
-        @performance
-        def my_function():
-            pass
-        
-        my_function()
-    """
+    Decorator to measure performance of a function, including
+    execution time and memory usage.
+
+    This decorator tracks:
+    - The number of times the function is called.
+    - The cumulative time taken by the function.
+    - The cumulative peak memory usage.
+
+    :param fn: The function to be wrapped and measured.
+    :return: The result of the wrapped function.
+    """  
+    if not hasattr(performance, 'counter'):
+        performance.counter = 0
+        performance.total_time = 0
+        performance.total_mem = 0
+
     def wrapper(*args, **kwargs):
-        global total_time, total_mem, counter
-        process = psutil.Process()
+        tracemalloc.start()
 
-        mem_before = process.memory_info().rss
         time_before = time.time()
 
-        counter += 1
-        fn(*args, **kwargs)
+        result = fn(*args, **kwargs)
 
         time_after = time.time()
-        total_time += time_after - time_before
 
-        mem_after = process.memory_info().rss
-        total_mem += mem_after - mem_before
+        curr_mem, peak_mem = tracemalloc.get_traced_memory()
+        tracemalloc.stop()
+
+        performance.counter += 1
+        performance.total_time += (time_after - time_before)  
+        performance.total_mem += peak_mem  
+
+        return result
 
     return wrapper