Extend SyclTimer

SyclTimer now supports device_timer keyword argument,
a legacy behavior "queue_barrier", and new one based
on sequential order manager, which inserts an empty task
into the manager to record start and end of block of timed
code.

Docstring of SyclTimer updated.

All data attributes needed for functioning of the timer are
created during class instance construction now.

Author: oleksandr-pavlyk

dpctl/_sycl_timer.py

@@ -44,6 +44,44 @@ def device_dt(self):
         return self._device_dt
 
 
+class BaseDeviceTimer:
+    __slots__ = ["queue"]
+
+    def __init__(self, sycl_queue):
+        if not isinstance(sycl_queue, SyclQueue):
+            raise TypeError(f"Expected type SyclQueue, got {type(sycl_queue)}")
+        self.queue = sycl_queue
+
+
+class QueueBarrierDeviceTimer(BaseDeviceTimer):
+    __slots__ = []
+
+    def __init__(self, sycl_queue):
+        super(QueueBarrierDeviceTimer, self).__init__(sycl_queue)
+
+    def get_event(self):
+        return self.queue.submit_barrier()
+
+
+class OrderManagerDeviceTimer(BaseDeviceTimer):
+    __slots__ = ["_order_manager", "_submit_empty_task_fn"]
+
+    def __init__(self, sycl_queue):
+        import dpctl.utils._seq_order_keeper as s_ok
+        from dpctl.utils import SequentialOrderManager as seq_om
+
+        super(OrderManagerDeviceTimer, self).__init__(sycl_queue)
+        self._order_manager = seq_om[self.queue]
+        self._submit_empty_task_fn = s_ok._submit_empty_task
+
+    def get_event(self):
+        ev = self._submit_empty_task_fn(
+            sycl_queue=self.queue, depends=self._order_manager.submitted_events
+        )
+        self._order_manager.add_event_pair(ev, ev)
+        return ev
+
+
 class SyclTimer:
     """
     Context to measure device time and host wall-time of execution
@@ -58,7 +96,7 @@ class SyclTimer:
             q = dpctl.SyclQueue(property="enable_profiling")
 
             # create the timer
-            milliseconds_sc = 1e-3
+            milliseconds_sc = 1e3
             timer = dpctl.SyclTimer(time_scale = milliseconds_sc)
 
             # use the timer
@@ -73,25 +111,36 @@ class SyclTimer:
             wall_dt, device_dt = timer.dt
 
     .. note::
-        The timer submits barriers to the queue at the entrance and the
+        The timer submits tasks to the queue at the entrance and the
         exit of the context and uses profiling information from events
         associated with these submissions to perform the timing. Thus
         :class:`dpctl.SyclTimer` requires the queue with ``"enable_profiling"``
         property. In order to be able to collect the profiling information,
         the ``dt`` property ensures that both submitted barriers complete their
         execution and thus effectively synchronizes the queue.
 
+        `device_timer` keyword argument controls the type of tasks submitted.
+        With `device_timer="queue_barrier"`, queue barrier tasks are used. With
+        `device_timer="order_manager"`, a single empty body task is inserted
+        instead relying on order manager (used by `dpctl.tensor` operations) to
+        order these tasks so that they fence operations performed within
+        timer's context.
+
     Args:
         host_timer (callable, optional):
             A callable such that host_timer() returns current
             host time in seconds.
             Default: :py:func:`timeit.default_timer`.
+        device_timer (Literal["queue_barrier", "order_manager"], optional):
+            Device timing method. Default: "queue_barrier".
         time_scale (Union[int, float], optional):
             Ratio of the unit of time of interest and one second.
             Default: ``1``.
     """
 
-    def __init__(self, host_timer=timeit.default_timer, time_scale=1):
+    def __init__(
+        self, host_timer=timeit.default_timer, device_timer=None, time_scale=1
+    ):
         """
         Create new instance of :class:`.SyclTimer`.
 
@@ -100,6 +149,8 @@ def __init__(self, host_timer=timeit.default_timer, time_scale=1):
                 A function that takes no arguments and returns a value
                 measuring time.
                 Default: :meth:`timeit.default_timer`.
+            device_timer (Literal["queue_barrier", "order_manager"], optional):
+                Device timing method. Default: "queue_barrier"
             time_scale (Union[int, float], optional):
                 Scaling factor applied to durations measured by
                 the host_timer. Default: ``1``.
@@ -109,11 +160,26 @@ def __init__(self, host_timer=timeit.default_timer, time_scale=1):
         self.queue = None
         self.host_times = []
         self.bracketing_events = []
+        self._context_data = list()
+        if device_timer is None:
+            device_timer = "queue_barrier"
+        if device_timer == "queue_barrier":
+            self._device_timer_class = QueueBarrierDeviceTimer
+        elif device_timer == "order_manager":
+            self._device_timer_class = OrderManagerDeviceTimer
+        else:
+            raise ValueError(
+                "Supported values for device_timer keyword are "
+                "'queue_barrier', 'order_manager', got "
+                f"'{device_timer}'"
+            )
+        self._device_timer = None
 
     def __call__(self, queue=None):
         if isinstance(queue, SyclQueue):
             if queue.has_enable_profiling:
                 self.queue = queue
+                self._device_timer = self._device_timer_class(queue)
             else:
                 raise ValueError(
                     "The given queue was not created with the "
@@ -127,17 +193,17 @@ def __call__(self, queue=None):
         return self
 
     def __enter__(self):
-        self._event_start = self.queue.submit_barrier()
-        self._host_start = self.timer()
+        _event_start = self._device_timer.get_event()
+        _host_start = self.timer()
+        self._context_data.append((_event_start, _host_start))
         return self
 
     def __exit__(self, *args):
-        self.host_times.append((self._host_start, self.timer()))
-        self.bracketing_events.append(
-            (self._event_start, self.queue.submit_barrier())
-        )
-        del self._event_start
-        del self._host_start
+        _event_end = self._device_timer.get_event()
+        _host_end = self.timer()
+        _event_start, _host_start = self._context_data.pop()
+        self.host_times.append((_host_start, _host_end))
+        self.bracketing_events.append((_event_start, _event_end))
 
     @property
     def dt(self):