rename to private fields/method

Co-authored-by: Andreas Klöckner <inform@tiker.net>

Author: matthiasdiener

arraycontext/impl/pytato/__init__.py

@@ -304,10 +304,10 @@ def __init__(
 
             # List of ProfileEvents that haven't been transferred to profiled
             # results yet
-            self.profile_events: list[ProfileEvent] = []
+            self._profile_events: list[ProfileEvent] = []
 
             # Dict of kernel name -> list of kernel execution times
-            self.profile_results: dict[str, list[int]] = {}
+            self._profile_results: dict[str, list[int]] = {}
 
         self.using_svm = None
 
@@ -362,25 +362,25 @@ def __init__(
     def _wait_and_transfer_profile_events(self) -> None:
         import pyopencl as cl
         # First, wait for completion of all events
-        if self.profile_events:
+        if self._profile_events:
             cl.wait_for_events([p_event.stop_cl_event
-                                    for p_event in self.profile_events])
+                                    for p_event in self._profile_events])
 
         # Then, collect all events and store them
-        for t in self.profile_events:
+        for t in self._profile_events:
             name = t.t_unit_name
 
             time = t.stop_cl_event.profile.end - t.start_cl_event.profile.end
 
-            self.profile_results.setdefault(name, []).append(time)
+            self._profile_results.setdefault(name, []).append(time)
 
-        self.profile_events = []
+        self._profile_events = []
 
-    def add_profiling_events(self, start: cl._cl.Event, stop: cl._cl.Event,
+    def _add_profiling_events(self, start: cl._cl.Event, stop: cl._cl.Event,
                              t_unit_name: str) -> None:
         """Add profiling events to the list of profiling events."""
         if self.profile_kernels:
-            self.profile_events.append(ProfileEvent(start, stop, t_unit_name))
+            self._profile_events.append(ProfileEvent(start, stop, t_unit_name))
 
     def get_profiling_data_for_kernel(self, kernel_name: str) \
           -> MultiCallKernelProfile:
@@ -410,10 +410,10 @@ def get_and_reset_profiling_data(self) -> dict[str, MultiCallKernelProfile]:
 
         result = {
             kernel_name: MultiCallKernelProfile(len(times), sum(times))
-            for kernel_name, times in self.profile_results.items()
+            for kernel_name, times in self._profile_results.items()
         }
 
-        self.profile_results = {}
+        self._profile_results = {}
 
         return result
 
@@ -653,7 +653,7 @@ def _to_frozen(key: tuple[Any, ...], ary) -> TaggableCLArray:
                 **bound_arguments)
 
         if self.profile_kernels:
-            self.add_profiling_events(start_evt, evt, pt_prg.program.entrypoint)
+            self._add_profiling_events(start_evt, evt, pt_prg.program.entrypoint)
 
         assert len(set(out_dict) & set(key_to_frozen_subary)) == 0
 

arraycontext/impl/pytato/compile.py

@@ -645,7 +645,7 @@ def __call__(self, arg_id_to_arg) -> ArrayContainer:
                                             **input_kwargs_for_loopy)
 
         if self.actx.profile_kernels:
-            self.actx.add_profiling_events(start_evt, evt, fn_name)
+            self.actx._add_profiling_events(start_evt, evt, fn_name)
 
         def to_output_template(keys, _):
             name_in_program = self.output_id_to_name_in_program[keys]
@@ -691,7 +691,7 @@ def __call__(self, arg_id_to_arg) -> ArrayContainer:
                                             **input_kwargs_for_loopy)
 
         if self.actx.profile_kernels:
-            self.actx.add_profiling_events(start_evt, evt, fn_name)
+            self.actx._add_profiling_events(start_evt, evt, fn_name)
 
         return self.actx.thaw(to_tagged_cl_array(out_dict[self.output_name],
                                                  axes=get_cl_axes_from_pt_axes(

test/test_pytato_arraycontext.py

@@ -290,54 +290,54 @@ def twice(x):
 
     f = actx.compile(twice)
 
-    assert len(actx.profile_events) == 0
+    assert len(actx._profile_events) == 0
 
     for _ in range(10):
         assert actx.to_numpy(f(99)) == 198
 
-    assert len(actx.profile_events) == 10
+    assert len(actx._profile_events) == 10
     actx._wait_and_transfer_profile_events()
-    assert len(actx.profile_events) == 0
-    assert len(actx.profile_results) == 1
-    assert len(actx.profile_results["twice"]) == 10
+    assert len(actx._profile_events) == 0
+    assert len(actx._profile_results) == 1
+    assert len(actx._profile_results["twice"]) == 10
 
     from arraycontext.impl.pytato.utils import tabulate_profiling_data
 
     print(tabulate_profiling_data(actx.get_and_reset_profiling_data()))
-    assert len(actx.profile_results) == 0
+    assert len(actx._profile_results) == 0
 
     # }}}
 
     # {{{ Uncompiled/frozen test
 
-    assert len(actx.profile_events) == 0
+    assert len(actx._profile_events) == 0
 
     for _ in range(10):
         assert np.all(actx.to_numpy(twice(actx.from_numpy(np.array([99, 99])))) == 198)
 
-    assert len(actx.profile_events) == 10
+    assert len(actx._profile_events) == 10
     actx._wait_and_transfer_profile_events()
-    assert len(actx.profile_events) == 0
-    assert len(actx.profile_results) == 1
-    assert len(actx.profile_results["frozen_result"]) == 10
+    assert len(actx._profile_events) == 0
+    assert len(actx._profile_results) == 1
+    assert len(actx._profile_results["frozen_result"]) == 10
 
     print(tabulate_profiling_data(actx.get_and_reset_profiling_data()))
 
-    assert len(actx.profile_results) == 0
+    assert len(actx._profile_results) == 0
 
     # }}}
 
     # {{{ test disabling profiling
 
     actx.profile_kernels = False
 
-    assert len(actx.profile_events) == 0
+    assert len(actx._profile_events) == 0
 
     for _ in range(10):
         assert actx.to_numpy(f(99)) == 198
 
-    assert len(actx.profile_events) == 0
-    assert len(actx.profile_results) == 0
+    assert len(actx._profile_events) == 0
+    assert len(actx._profile_results) == 0
 
     # }}}