added initial memory tracking

Author: Saher-Amasha

example_usage/example1.py

@@ -1,21 +1,28 @@
 import random
+import resource
 from time import sleep
 
 from logic.profiling_meta import ProfilingMeta
 
 
 
+from resource import *
+import time
+
+# a non CPU-bound task
+time.sleep(3)
 
 class Example(metaclass=ProfilingMeta):
 
     @staticmethod
     def ex1_func():
+        a = [1] * (10 ** 6) 
+        b = [1] * (10 ** 6) 
         print("1")
         sleep(2)
         Example.ex2_func()
         sleep(3)
         print("2")
-
     @staticmethod
     def ex2_func():
         print("1")
@@ -24,6 +31,8 @@ def ex2_func():
 
     @staticmethod
     def ex3_func():
+        a = [1] * (10 ** 7) 
+        b = [1] * (10 ** 7) 
         print("1")
         sleep(random.randint(0,5))
         print("2")

logic/profiling_decorators.py

@@ -1,5 +1,7 @@
 
+import functools
 import os
+import resource
 import socket
 from datetime import datetime
 import uuid
@@ -9,6 +11,7 @@ class ProfilingDecorators:
     PORT = int(os.environ.get('PORT', "65433") )
 
     def time_profile(func):
+        @functools.wraps(func)
         def wrapper(*args, **kwargs):
             start = datetime.now()
             val = func(*args, **kwargs)
@@ -18,4 +21,15 @@ def wrapper(*args, **kwargs):
                 s.sendall(bytes('time;'+str(uuid.uuid1()) +';'+str(func.__name__) +';'+ str(start) + ';'+str(end), 'utf-8'))
             return val
         return wrapper
+    def memory_profile(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            start = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+            val = func(*args, **kwargs)
+            end = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.connect((ProfilingDecorators.HOST, ProfilingDecorators.PORT))
+                s.sendall(bytes('memory;'+str(uuid.uuid1()) +';'+str(func.__name__) +';'+ str(start) + ';'+str(end), 'utf-8'))
+            return val
+        return wrapper
 

logic/profiling_meta.py

@@ -1,9 +1,8 @@
 from logic.profiling_decorators import ProfilingDecorators
 
-
 class ProfilingMeta(type):
     def __new__(cls, name, bases, class_dict):
         for key, value in class_dict.items():
             if callable(value):
-                class_dict[key] = ProfilingDecorators.time_profile(value)
+                class_dict[key] = ProfilingDecorators.time_profile(ProfilingDecorators.memory_profile(value))
         return super().__new__(cls, name, bases, class_dict)

logic/stamps/memory_stamp.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+
+from logic.stamps.base_stamp import BaseStamp
+
+
+@dataclass
+class MemoryStamp(BaseStamp):
+    """
+    object that holds a time stap and additional info about the function
+    """
+    start_memory:float
+    end_memory:float
+
+    @staticmethod
+    def init_from_bytes(split_desc_string):
+        """
+        init date time from a string
+        """
+        if len(split_desc_string) > 0:
+
+            id = split_desc_string[0]
+            name = split_desc_string[1]
+            start_memory = float(split_desc_string[2])
+            end_memory = float(split_desc_string[3])
+
+            return MemoryStamp(id=id,name=name,start_memory=start_memory,end_memory=end_memory)
+    
+    def __lt__(self, other):
+        return self.end_memory  - self.start_memory < other.end_memory - other.start_memory

profiler_server.py

@@ -1,6 +1,7 @@
 import os
 import socket
 from controller import Model
+from logic.stamps.memory_stamp import MemoryStamp
 
 from logic.stamps.time_stamp import TimeStamp
 
@@ -32,7 +33,7 @@ def init_stamp_from_bytes(data):
             match split_desc_string[0]:
                 case 'time':
                     Model.add_time_stamp(split_desc_string[1],TimeStamp.init_from_bytes(split_desc_string[1:]))
-                case 'mem':
+                case 'memory':
                     # TODO FIX
-                    Model.add_memmory_stamp(split_desc_string[1],TimeStamp.init_from_bytes(split_desc_string[1:]))
+                    Model.add_memmory_stamp(split_desc_string[1],MemoryStamp.init_from_bytes(split_desc_string[1:]))
 

view/base_view.py

@@ -2,10 +2,15 @@
 
 
 @dataclass
-class Baseview():
+class Baseview:
     width:int = 500
     height:int = 500
     color:str = '#FFFFFF'
     canvas_scaler:int=40
     rectange_height:int = 60
-    rectange_spacing:int = 5 
+    rectange_width:int = 20
+    rectange_spacing:int = 5 
+    def draw_rect(self,x1,x2,y1,y2): 
+        self.canvas.create_rectangle((x1,x2,y1,y2),fill='red')
+    def destroy(self):
+        self.frame.destroy()

view/memory_view.py

@@ -1,4 +1,5 @@
 from tkinter import *
+from controller import Model
 
 from view.base_view import Baseview
 
@@ -9,23 +10,46 @@ def __init__(self,root) -> None:
         self.root=root
         self.frame=Frame(self.root,width=self.width,height=self.height)
         label = Label(self.frame,text="Memory profiling")
-        label.pack()
+        copy = Model.MEMORY_STAMPS.copy()
 
+        mlist = list(copy.values())
+        if len(copy) > 0:
+            self.canvas=Canvas(self.frame,bg=self.color,width=self.width,height=self.height,scrollregion=(0,0,max(self.rectange_width*len(copy),self.width),max(max(mlist).end_memory -  max(mlist).start_memory,self.height*self.canvas_scaler)))
+        else :
+            self.canvas=Canvas(self.frame,bg=self.color,width=self.width,height=self.height,scrollregion=(0,0,self.width*self.canvas_scaler,self.height*self.canvas_scaler))
     def draw(self):
         self.frame.pack(expand=True, fill=BOTH)
-        canvas=Canvas(self.frame,bg=self.color,width=self.width,height=self.height,scrollregion=(0,0,self.width*self.canvas_scaler,self.height*self.canvas_scaler))
+        
         hbar=Scrollbar(self.frame,orient=HORIZONTAL)
         hbar.pack(side=BOTTOM,fill=X)
-        hbar.config(command=canvas.xview)
+        hbar.config(command=self.canvas.xview)
         vbar=Scrollbar(self.frame,orient=VERTICAL)
         vbar.pack(side=RIGHT,fill=Y)
-        vbar.config(command=canvas.yview)
-        canvas.config(width=self.width,height=self.height)
-        canvas.config(xscrollcommand=hbar.set, yscrollcommand=vbar.set)
-        canvas.pack(side=LEFT,expand=True,fill=BOTH)
+        vbar.config(command=self.canvas.yview)
+        self.canvas.config(width=self.width,height=self.height)
+        self.canvas.config(xscrollcommand=hbar.set, yscrollcommand=vbar.set)
+        self.canvas.pack(side=LEFT,expand=True,fill=BOTH)
+        self.update()
 
-    def draw_rect(self,x1,x2,y1,y2):
-        self.canvas.create_rectangle((x1,x2,y1,y2))
-        
-    def destroy(self):
-        self.frame.destroy()
+    def update(self):
+        copy = Model.MEMORY_STAMPS.copy()
+        if len(copy) <=0:
+            return
+        mlist = list(copy.values())
+        mlist_sorted= sorted(mlist)
+        max_mlist=max(mlist)
+        for index,i in enumerate(mlist_sorted):
+            memory_stamp = i
+            memory_leaked = memory_stamp.end_memory -  memory_stamp.start_memory
+            if memory_leaked == 0 :
+                continue
+            self.scaler = 1/10
+            x = index * (self.rectange_width + self.rectange_spacing)
+            y = (max_mlist.end_memory -  max_mlist.start_memory) *self.scaler
+            width = x + self.rectange_width + 50
+            height = memory_leaked *self.scaler# it is in kb
+            self.draw_rect( x ,y ,width ,height)    
+            
+            self.canvas.create_text((x  + width )/2 ,(y +height)/2 -self.rectange_height/3 , text=memory_stamp.name , fill="white")
+            self.canvas.create_text((x  + width )/2 ,(y +height)/2 , text='memory_leaked: '+str(memory_leaked), fill="white")
+            self.canvas.create_text((x  + width )/2 ,(y +height)/2 +self.rectange_height/3, text=memory_stamp.id, fill="white")

view/time_view.py

@@ -48,7 +48,3 @@ def update(self):
                 self.canvas.create_text((x  + width )/2 ,(y +height)/2 -self.rectange_height/3 , text=time_stamp.name , fill="white")
                 self.canvas.create_text((x  + width )/2 ,(y +height)/2 , text=str(time.seconds)+' seconds', fill="white")
                 self.canvas.create_text((x  + width )/2 ,(y +height)/2 +self.rectange_height/3, text=time_stamp.id, fill="white")
-    def draw_rect(self,x1,x2,y1,y2): 
-        self.canvas.create_rectangle((x1,x2,y1,y2),fill='red')
-    def destroy(self):
-        self.frame.destroy()