Model breakdown - device utilization (#61)

* added logic for sending gpu utilization data

* added tensor core usage

* change logging output

* changed ignored file names

* changed gitignore

* created disconnection function

* review changes

* deleted commented code

* changed logic for gpu time calculations

* added warm-up step for pytorch profiling

* added message to error_message

* added multiprocess

* Fixed launching deepview from command line

Author: johncalesp

deepview_profile/__init__.py

@@ -9,3 +9,5 @@
 __name__ = package["tool"]["poetry"]["name"]
 __version__ = package["tool"]["poetry"]["version"]
 __description__ = package["tool"]["poetry"]["description"]
+
+from .__main__ import main

deepview_profile/analysis/request_manager.py

@@ -2,7 +2,7 @@
 import math
 import time
 from concurrent.futures import ThreadPoolExecutor
-
+import torch.multiprocessing as mp
 from deepview_profile.analysis.runner import analyze_project
 from deepview_profile.exceptions import AnalysisError
 from deepview_profile.nvml import NVML
@@ -24,6 +24,7 @@ def __init__(self, enqueue_response, message_sender, connection_manager):
         self._message_sender = message_sender
         self._connection_manager = connection_manager
         self._nvml = NVML()
+        mp.set_start_method("spawn")
 
     def start(self):
         self._nvml.start()
@@ -52,18 +53,13 @@ def _handle_analysis_request(self, analysis_request, context):
                 context.sequence_number,
                 *(context.address),
             )
-            connection = self._connection_manager.get_connection(context.address)
+            connection = self._connection_manager.get_connection(
+                context.address)
             analyzer = analyze_project(
                 connection.project_root, connection.entry_point, self._nvml)
 
             # Abort early if the connection has been closed
-            if not context.state.connected:
-                logger.error(
-                    'Aborting request %d from (%s:%d) early '
-                    'because the client has disconnected.',
-                    context.sequence_number,
-                    *(context.address),
-                )
+            if self._early_disconnection_error(context):
                 return
 
             breakdown = next(analyzer)
@@ -73,13 +69,7 @@ def _handle_analysis_request(self, analysis_request, context):
                 context,
             )
 
-            if not context.state.connected:
-                logger.error(
-                    'Aborting request %d from (%s:%d) early '
-                    'because the client has disconnected.',
-                    context.sequence_number,
-                    *(context.address),
-                )
+            if self._early_disconnection_error(context):
                 return
 
             throughput = next(analyzer)
@@ -90,13 +80,7 @@ def _handle_analysis_request(self, analysis_request, context):
             )
 
             # send habitat response
-            if not context.state.connected:
-                logger.error(
-                    'Aborting request %d from (%s:%d) early '
-                    'because the client has disconnected.',
-                    context.sequence_number,
-                    *(context.address),
-                )
+            if self._early_disconnection_error(context):
                 return
 
             habitat_resp = next(analyzer)
@@ -106,14 +90,19 @@ def _handle_analysis_request(self, analysis_request, context):
                 context,
             )
 
+            # send utilization data
+            if self._early_disconnection_error(context):
+                return
+
+            utilization_resp = next(analyzer)
+            self._enqueue_response(
+                self._send_utilization_response,
+                utilization_resp,
+                context
+            )
+
             # send energy response
-            if not context.state.connected:
-                logger.error(
-                    'Aborting request %d from (%s:%d) early '
-                    'because the client has disconnected.',
-                    context.sequence_number,
-                    *(context.address),
-                )
+            if self._early_disconnection_error(context):
                 return
 
             energy_resp = next(analyzer)
@@ -198,3 +187,24 @@ def _send_energy_response(self, energy_resp, context):
         except Exception:
             logger.exception(
                 'Exception occurred when sending an energy response.')
+
+    def _send_utilization_response(self, utilization_resp, context):
+        # Called from the main executor. Do not call directly!
+        try:
+            self._message_sender.send_utilization_response(
+                utilization_resp, context)
+        except Exception:
+            logger.exception(
+                'Exception occurred when sending utilization response.')
+
+    def _early_disconnection_error(self, context):
+        if not context.state.connected:
+            logger.error(
+                'Aborting request %d from (%s:%d) early '
+                'because the client has disconnected.',
+                context.sequence_number,
+                *(context.address),
+            )
+            return True
+
+        return False

deepview_profile/analysis/runner.py

@@ -1,24 +1,31 @@
 import argparse
 import logging
 import os
-
-import torch
 from deepview_profile.analysis.session import AnalysisSession
 from deepview_profile.nvml import NVML
 from deepview_profile.utils import release_memory
 
+
 def analyze_project(project_root, entry_point, nvml):
-    release_memory()
     session = AnalysisSession.new_from(project_root, entry_point)
+    release_memory()
+
+    print("analyze_project: running measure_breakdown()")
     yield session.measure_breakdown(nvml)
     release_memory()
+
+    print("analyze_project: running measure_throughput()")
     yield session.measure_throughput()
     release_memory()
 
     print("analyze_project: running deepview_predict()")
     yield session.habitat_predict()
     release_memory()
 
+    print("analyze_project: running measure_utilization()")
+    yield session.measure_utilization()
+    release_memory()
+
     print("analyze_project: running energy_compute()")
     yield session.energy_compute()
     release_memory()