[Intel-gfx] [PATCH 0/1] Add support for querying engine cycles

[Intel-gfx] [PATCH 0/1] Add support for querying engine cycles

[Umesh Nerlige Ramappa]

This is just a refresh of the earlier patch along with cover letter for the IGT
testing. The query provides the engine cs cycles counter.

v2: Use GRAPHICS_VER() instead of IG_GEN()
v3: Add R-b to the patch
v4: Split cpu timestamp array into timestamp and delta for cleaner API
v5: Add width of the cs cycles to the uapi

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Test-with: 20210504001003.69445-1-umesh.nerlige.ramappa@intel.com

Umesh Nerlige Ramappa (1):
  i915/query: Correlate engine and cpu timestamps with better accuracy

 drivers/gpu/drm/i915/i915_query.c | 157 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  56 +++++++++++
 2 files changed, 213 insertions(+)

-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

Perf measurements rely on CPU and engine timestamps to correlate
events of interest across these time domains. Current mechanisms get
these timestamps separately and the calculated delta between these
timestamps lack enough accuracy.

To improve the accuracy of these time measurements to within a few us,
add a query that returns the engine and cpu timestamps captured as
close to each other as possible.

v2: (Tvrtko)
- document clock reference used
- return cpu timestamp always
- capture cpu time just before lower dword of cs timestamp

v3: (Chris)
- use uncore-rpm
- use __query_cs_timestamp helper

v4: (Lionel)
- Kernel perf subsytem allows users to specify the clock id to be used
  in perf_event_open. This clock id is used by the perf subsystem to
  return the appropriate cpu timestamp in perf events. Similarly, let
  the user pass the clockid to this query so that cpu timestamp
  corresponds to the clock id requested.

v5: (Tvrtko)
- Use normal ktime accessors instead of fast versions
- Add more uApi documentation

v6: (Lionel)
- Move switch out of spinlock

v7: (Chris)
- cs_timestamp is a misnomer, use cs_cycles instead
- return the cs cycle frequency as well in the query

v8:
- Add platform and engine specific checks

v9: (Lionel)
- Return 2 cpu timestamps in the query - captured before and after the
  register read

v10: (Chris)
- Use local_clock() to measure time taken to read lower dword of
  register and return it to user.

v11: (Jani)
- IS_GEN deprecated. User GRAPHICS_VER instead.

v12: (Jason)
- Split cpu timestamp array into timestamp and delta for cleaner API

v13:
- Return the width of cs cycles
- Conform to kernel doc format

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
---
 drivers/gpu/drm/i915/i915_query.c | 157 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  56 +++++++++++
 2 files changed, 213 insertions(+)

diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
index fed337ad7b68..2e7039c71866 100644
--- a/drivers/gpu/drm/i915/i915_query.c
+++ b/drivers/gpu/drm/i915/i915_query.c
@@ -6,6 +6,8 @@
 
 #include <linux/nospec.h>
 
+#include "gt/intel_engine_pm.h"
+#include "gt/intel_engine_user.h"
 #include "i915_drv.h"
 #include "i915_perf.h"
 #include "i915_query.h"
@@ -90,6 +92,160 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
 	return total_length;
 }
 
+typedef u64 (*__ktime_func_t)(void);
+static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
+{
+	/*
+	 * Use logic same as the perf subsystem to allow user to select the
+	 * reference clock id to be used for timestamps.
+	 */
+	switch (clk_id) {
+	case CLOCK_MONOTONIC:
+		return &ktime_get_ns;
+	case CLOCK_MONOTONIC_RAW:
+		return &ktime_get_raw_ns;
+	case CLOCK_REALTIME:
+		return &ktime_get_real_ns;
+	case CLOCK_BOOTTIME:
+		return &ktime_get_boottime_ns;
+	case CLOCK_TAI:
+		return &ktime_get_clocktai_ns;
+	default:
+		return NULL;
+	}
+}
+
+static inline int
+__read_timestamps(struct intel_uncore *uncore,
+		  i915_reg_t lower_reg,
+		  i915_reg_t upper_reg,
+		  u64 *cs_ts,
+		  u64 *cpu_ts,
+		  u64 *cpu_delta,
+		  __ktime_func_t cpu_clock)
+{
+	u32 upper, lower, old_upper, loop = 0;
+
+	upper = intel_uncore_read_fw(uncore, upper_reg);
+	do {
+		*cpu_delta = local_clock();
+		*cpu_ts = cpu_clock();
+		lower = intel_uncore_read_fw(uncore, lower_reg);
+		*cpu_delta = local_clock() - *cpu_delta;
+		old_upper = upper;
+		upper = intel_uncore_read_fw(uncore, upper_reg);
+	} while (upper != old_upper && loop++ < 2);
+
+	*cs_ts = (u64)upper << 32 | lower;
+
+	return 0;
+}
+
+static int
+__query_cs_cycles(struct intel_engine_cs *engine,
+		  u64 *cs_ts, u64 *cpu_ts, u64 *cpu_delta,
+		  __ktime_func_t cpu_clock)
+{
+	struct intel_uncore *uncore = engine->uncore;
+	enum forcewake_domains fw_domains;
+	u32 base = engine->mmio_base;
+	intel_wakeref_t wakeref;
+	int ret;
+
+	fw_domains = intel_uncore_forcewake_for_reg(uncore,
+						    RING_TIMESTAMP(base),
+						    FW_REG_READ);
+
+	with_intel_runtime_pm(uncore->rpm, wakeref) {
+		spin_lock_irq(&uncore->lock);
+		intel_uncore_forcewake_get__locked(uncore, fw_domains);
+
+		ret = __read_timestamps(uncore,
+					RING_TIMESTAMP(base),
+					RING_TIMESTAMP_UDW(base),
+					cs_ts,
+					cpu_ts,
+					cpu_delta,
+					cpu_clock);
+
+		intel_uncore_forcewake_put__locked(uncore, fw_domains);
+		spin_unlock_irq(&uncore->lock);
+	}
+
+	return ret;
+}
+
+static int
+query_cs_cycles(struct drm_i915_private *i915,
+		struct drm_i915_query_item *query_item)
+{
+	struct drm_i915_query_cs_cycles __user *query_ptr;
+	struct drm_i915_query_cs_cycles query;
+	struct intel_engine_cs *engine;
+	__ktime_func_t cpu_clock;
+	u32 width;
+	int ret;
+
+	if (GRAPHICS_VER(i915) < 6)
+		return -ENODEV;
+
+	query_ptr = u64_to_user_ptr(query_item->data_ptr);
+	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
+	if (ret != 0)
+		return ret;
+
+	if (query.flags)
+		return -EINVAL;
+
+	if (query.rsvd)
+		return -EINVAL;
+
+	cpu_clock = __clock_id_to_func(query.clockid);
+	if (!cpu_clock)
+		return -EINVAL;
+
+	engine = intel_engine_lookup_user(i915,
+					  query.engine.engine_class,
+					  query.engine.engine_instance);
+	if (!engine)
+		return -EINVAL;
+
+	if (GRAPHICS_VER(i915) == 6) {
+		if (query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
+			return -ENODEV;
+
+		width = 32;
+	} else {
+		width = 36;
+	}
+
+	query.cs_frequency = engine->gt->clock_frequency;
+	ret = __query_cs_cycles(engine,
+				&query.cs_cycles,
+				&query.cpu_timestamp,
+				&query.cpu_delta,
+				cpu_clock);
+	if (ret)
+		return ret;
+
+	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp, &query_ptr->cpu_timestamp))
+		return -EFAULT;
+
+	if (put_user(query.cpu_delta, &query_ptr->cpu_delta))
+		return -EFAULT;
+
+	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
+		return -EFAULT;
+
+	if (put_user(width, &query_ptr->width))
+		return -EFAULT;
+
+	return sizeof(query);
+}
+
 static int
 query_engine_info(struct drm_i915_private *i915,
 		  struct drm_i915_query_item *query_item)
@@ -424,6 +580,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
 	query_topology_info,
 	query_engine_info,
 	query_perf_config,
+	query_cs_cycles,
 };
 
 int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
index 6a34243a7646..17ac6135f9a7 100644
--- a/include/uapi/drm/i915_drm.h
+++ b/include/uapi/drm/i915_drm.h
@@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
 #define DRM_I915_QUERY_TOPOLOGY_INFO    1
 #define DRM_I915_QUERY_ENGINE_INFO	2
 #define DRM_I915_QUERY_PERF_CONFIG      3
+	/**
+	 * Query Command Streamer timestamp register.
+	 */
+#define DRM_I915_QUERY_CS_CYCLES	4
 /* Must be kept compact -- no holes and well documented */
 
 	/**
@@ -2397,6 +2401,58 @@ struct drm_i915_engine_info {
 	__u64 rsvd1[4];
 };
 
+/**
+ * struct drm_i915_query_cs_cycles
+ *
+ * The query returns the command streamer cycles, the frequency that can be
+ * used to calculate the command streamer timestamp, a cpu timestamp indicating
+ * when the cs cycles was captured and a cpu_delta capturing time taken to read
+ * the cs_cycles register.
+ */
+struct drm_i915_query_cs_cycles {
+	/** @engine: Engine for which command streamer cycles is queried. */
+	struct i915_engine_class_instance engine;
+
+	/** @flags: MBZ */
+	__u32 flags;
+
+	/**
+	 * @cs_cycles: Command streamer cycles as read from the command streamer
+	 * register at 0x358 offset.
+	 */
+	__u64 cs_cycles;
+
+	/** @cs_frequency: Frequency of the cs cycles in Hz. */
+	__u64 cs_frequency;
+
+	/** @width: Width of the cs cycles in bits. */
+	__u64 width;
+
+	/**
+	 * @cpu_timestamp: CPU timestamp in ns. The timestamp is captured before
+	 * reading the cs_cycles register using the reference clockid set by the
+	 * user.
+	 */
+	__u64 cpu_timestamp;
+
+	/**
+	 * @cpu_delta: Time delta in ns captured around reading the lower dword
+	 * of the cs_cycles register.
+	 */
+	__u64 cpu_delta;
+
+	/**
+	 * @clockid: Reference clock id for CPU timestamp. For definition, see
+	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
+	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
+	 * CLOCK_TAI.
+	 */
+	__s32 clockid;
+
+	/** @rsvd: MBZ */
+	__u32 rsvd;
+};
+
 /**
  * struct drm_i915_query_engine_info
  *
-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] ✗ Fi.CI.DOCS: warning for Add support for querying engine cycles

[Patchwork]

== Series Details ==

Series: Add support for querying engine cycles
URL   : https://patchwork.freedesktop.org/series/89766/
State : warning

== Summary ==

$ make htmldocs 2>&1 > /dev/null | grep i915
./include/uapi/drm/i915_drm.h:2234: warning: Incorrect use of kernel-doc format:          * Query Command Streamer timestamp register.


_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] ✗ Fi.CI.BAT: failure for Add support for querying engine cycles

[Patchwork]

[-- Attachment #1.1: Type: text/plain, Size: 3696 bytes --]

== Series Details ==

Series: Add support for querying engine cycles
URL   : https://patchwork.freedesktop.org/series/89766/
State : failure

== Summary ==

CI Bug Log - changes from CI_DRM_10040 -> Patchwork_20059
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with Patchwork_20059 absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in Patchwork_20059, please notify your bug team to allow them
  to document this new failure mode, which will reduce false positives in CI.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_20059/index.html

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in Patchwork_20059:

### CI changes ###

#### Possible regressions ####

  * boot:
    - fi-kbl-soraka:      [PASS][1] -> [FAIL][2]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_10040/fi-kbl-soraka/boot.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_20059/fi-kbl-soraka/boot.html

  
Known issues
------------

  Here are the changes found in Patchwork_20059 that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@amdgpu/amd_cs_nop@fork-gfx0:
    - fi-tgl-y:           NOTRUN -> [SKIP][3] ([fdo#109315] / [i915#2575]) +6 similar issues
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_20059/fi-tgl-y/igt@amdgpu/amd_cs_nop@fork-gfx0.html

  * igt@amdgpu/amd_cs_nop@sync-fork-compute0:
    - fi-snb-2600:        NOTRUN -> [SKIP][4] ([fdo#109271]) +17 similar issues
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_20059/fi-snb-2600/igt@amdgpu/amd_cs_nop@sync-fork-compute0.html

  
#### Possible fixes ####

  * igt@i915_selftest@live@hangcheck:
    - fi-snb-2600:        [INCOMPLETE][5] ([i915#2782]) -> [PASS][6]
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_10040/fi-snb-2600/igt@i915_selftest@live@hangcheck.html
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_20059/fi-snb-2600/igt@i915_selftest@live@hangcheck.html

  
#### Warnings ####

  * igt@i915_pm_rpm@basic-rte:
    - fi-kbl-guc:         [SKIP][7] ([fdo#109271]) -> [FAIL][8] ([i915#3049])
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_10040/fi-kbl-guc/igt@i915_pm_rpm@basic-rte.html
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_20059/fi-kbl-guc/igt@i915_pm_rpm@basic-rte.html

  
  [fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
  [fdo#109315]: https://bugs.freedesktop.org/show_bug.cgi?id=109315
  [i915#2575]: https://gitlab.freedesktop.org/drm/intel/issues/2575
  [i915#2782]: https://gitlab.freedesktop.org/drm/intel/issues/2782
  [i915#3049]: https://gitlab.freedesktop.org/drm/intel/issues/3049


Participating hosts (46 -> 41)
------------------------------

  Missing    (5): fi-ilk-m540 fi-hsw-4200u fi-bsw-cyan fi-ctg-p8600 fi-bdw-samus 


Build changes
-------------

  * IGT: IGT_6077 -> IGTPW_5777
  * Linux: CI_DRM_10040 -> Patchwork_20059

  CI-20190529: 20190529
  CI_DRM_10040: 6645780dc86cd92b4f56b88a92c2e04cb0811ebc @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_5777: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_5777/index.html
  IGT_6077: 126a3f6fc0e97786e2819085efc84e741093aed5 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
  Patchwork_20059: f19b3e6fde2f33a6add73df8e3e5a72c06a387d1 @ git://anongit.freedesktop.org/gfx-ci/linux


== Linux commits ==

f19b3e6fde2f i915/query: Correlate engine and cpu timestamps with better accuracy

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_20059/index.html

[-- Attachment #1.2: Type: text/html, Size: 4490 bytes --]

[-- Attachment #2: Type: text/plain, Size: 160 bytes --]

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 0/1] Add support for querying engine cycles

[Umesh Nerlige Ramappa]

This is just a refresh of the earlier patch along with cover letter for the IGT
testing. The query provides the engine cs cycles counter.

v2: Use GRAPHICS_VER() instead of IG_GEN()
v3: Add R-b to the patch
v4: Split cpu timestamp array into timestamp and delta for cleaner API

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Test-with: 20210429002959.69473-1-umesh.nerlige.ramappa@intel.com

Umesh Nerlige Ramappa (1):
  i915/query: Correlate engine and cpu timestamps with better accuracy

 drivers/gpu/drm/i915/i915_query.c | 148 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  52 +++++++++++
 2 files changed, 200 insertions(+)

-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

Perf measurements rely on CPU and engine timestamps to correlate
events of interest across these time domains. Current mechanisms get
these timestamps separately and the calculated delta between these
timestamps lack enough accuracy.

To improve the accuracy of these time measurements to within a few us,
add a query that returns the engine and cpu timestamps captured as
close to each other as possible.

v2: (Tvrtko)
- document clock reference used
- return cpu timestamp always
- capture cpu time just before lower dword of cs timestamp

v3: (Chris)
- use uncore-rpm
- use __query_cs_timestamp helper

v4: (Lionel)
- Kernel perf subsytem allows users to specify the clock id to be used
  in perf_event_open. This clock id is used by the perf subsystem to
  return the appropriate cpu timestamp in perf events. Similarly, let
  the user pass the clockid to this query so that cpu timestamp
  corresponds to the clock id requested.

v5: (Tvrtko)
- Use normal ktime accessors instead of fast versions
- Add more uApi documentation

v6: (Lionel)
- Move switch out of spinlock

v7: (Chris)
- cs_timestamp is a misnomer, use cs_cycles instead
- return the cs cycle frequency as well in the query

v8:
- Add platform and engine specific checks

v9: (Lionel)
- Return 2 cpu timestamps in the query - captured before and after the
  register read

v10: (Chris)
- Use local_clock() to measure time taken to read lower dword of
  register and return it to user.

v11: (Jani)
- IS_GEN deprecated. User GRAPHICS_VER instead.

v12: (Jason)
- Split cpu timestamp array into timestamp and delta for cleaner API

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
---
 drivers/gpu/drm/i915/i915_query.c | 148 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  52 +++++++++++
 2 files changed, 200 insertions(+)

diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
index fed337ad7b68..357c44e8177c 100644
--- a/drivers/gpu/drm/i915/i915_query.c
+++ b/drivers/gpu/drm/i915/i915_query.c
@@ -6,6 +6,8 @@
 
 #include <linux/nospec.h>
 
+#include "gt/intel_engine_pm.h"
+#include "gt/intel_engine_user.h"
 #include "i915_drv.h"
 #include "i915_perf.h"
 #include "i915_query.h"
@@ -90,6 +92,151 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
 	return total_length;
 }
 
+typedef u64 (*__ktime_func_t)(void);
+static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
+{
+	/*
+	 * Use logic same as the perf subsystem to allow user to select the
+	 * reference clock id to be used for timestamps.
+	 */
+	switch (clk_id) {
+	case CLOCK_MONOTONIC:
+		return &ktime_get_ns;
+	case CLOCK_MONOTONIC_RAW:
+		return &ktime_get_raw_ns;
+	case CLOCK_REALTIME:
+		return &ktime_get_real_ns;
+	case CLOCK_BOOTTIME:
+		return &ktime_get_boottime_ns;
+	case CLOCK_TAI:
+		return &ktime_get_clocktai_ns;
+	default:
+		return NULL;
+	}
+}
+
+static inline int
+__read_timestamps(struct intel_uncore *uncore,
+		  i915_reg_t lower_reg,
+		  i915_reg_t upper_reg,
+		  u64 *cs_ts,
+		  u64 *cpu_ts,
+		  u64 *cpu_delta,
+		  __ktime_func_t cpu_clock)
+{
+	u32 upper, lower, old_upper, loop = 0;
+
+	upper = intel_uncore_read_fw(uncore, upper_reg);
+	do {
+		*cpu_delta = local_clock();
+		*cpu_ts = cpu_clock();
+		lower = intel_uncore_read_fw(uncore, lower_reg);
+		*cpu_delta = local_clock() - *cpu_delta;
+		old_upper = upper;
+		upper = intel_uncore_read_fw(uncore, upper_reg);
+	} while (upper != old_upper && loop++ < 2);
+
+	*cs_ts = (u64)upper << 32 | lower;
+
+	return 0;
+}
+
+static int
+__query_cs_cycles(struct intel_engine_cs *engine,
+		  u64 *cs_ts, u64 *cpu_ts, u64 *cpu_delta,
+		  __ktime_func_t cpu_clock)
+{
+	struct intel_uncore *uncore = engine->uncore;
+	enum forcewake_domains fw_domains;
+	u32 base = engine->mmio_base;
+	intel_wakeref_t wakeref;
+	int ret;
+
+	fw_domains = intel_uncore_forcewake_for_reg(uncore,
+						    RING_TIMESTAMP(base),
+						    FW_REG_READ);
+
+	with_intel_runtime_pm(uncore->rpm, wakeref) {
+		spin_lock_irq(&uncore->lock);
+		intel_uncore_forcewake_get__locked(uncore, fw_domains);
+
+		ret = __read_timestamps(uncore,
+					RING_TIMESTAMP(base),
+					RING_TIMESTAMP_UDW(base),
+					cs_ts,
+					cpu_ts,
+					cpu_delta,
+					cpu_clock);
+
+		intel_uncore_forcewake_put__locked(uncore, fw_domains);
+		spin_unlock_irq(&uncore->lock);
+	}
+
+	return ret;
+}
+
+static int
+query_cs_cycles(struct drm_i915_private *i915,
+		struct drm_i915_query_item *query_item)
+{
+	struct drm_i915_query_cs_cycles __user *query_ptr;
+	struct drm_i915_query_cs_cycles query;
+	struct intel_engine_cs *engine;
+	__ktime_func_t cpu_clock;
+	int ret;
+
+	if (GRAPHICS_VER(i915) < 6)
+		return -ENODEV;
+
+	query_ptr = u64_to_user_ptr(query_item->data_ptr);
+	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
+	if (ret != 0)
+		return ret;
+
+	if (query.flags)
+		return -EINVAL;
+
+	if (query.rsvd)
+		return -EINVAL;
+
+	cpu_clock = __clock_id_to_func(query.clockid);
+	if (!cpu_clock)
+		return -EINVAL;
+
+	engine = intel_engine_lookup_user(i915,
+					  query.engine.engine_class,
+					  query.engine.engine_instance);
+	if (!engine)
+		return -EINVAL;
+
+	if (GRAPHICS_VER(i915) == 6 &&
+	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
+		return -ENODEV;
+
+	query.cs_frequency = engine->gt->clock_frequency;
+	ret = __query_cs_cycles(engine,
+				&query.cs_cycles,
+				&query.cpu_timestamp,
+				&query.cpu_delta,
+				cpu_clock);
+	if (ret)
+		return ret;
+
+	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp, &query_ptr->cpu_timestamp))
+		return -EFAULT;
+
+	if (put_user(query.cpu_delta, &query_ptr->cpu_delta))
+		return -EFAULT;
+
+	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
+		return -EFAULT;
+
+	return sizeof(query);
+}
+
 static int
 query_engine_info(struct drm_i915_private *i915,
 		  struct drm_i915_query_item *query_item)
@@ -424,6 +571,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
 	query_topology_info,
 	query_engine_info,
 	query_perf_config,
+	query_cs_cycles,
 };
 
 int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
index 6a34243a7646..0b4c27092d41 100644
--- a/include/uapi/drm/i915_drm.h
+++ b/include/uapi/drm/i915_drm.h
@@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
 #define DRM_I915_QUERY_TOPOLOGY_INFO    1
 #define DRM_I915_QUERY_ENGINE_INFO	2
 #define DRM_I915_QUERY_PERF_CONFIG      3
+	/**
+	 * Query Command Streamer timestamp register.
+	 */
+#define DRM_I915_QUERY_CS_CYCLES	4
 /* Must be kept compact -- no holes and well documented */
 
 	/**
@@ -2397,6 +2401,54 @@ struct drm_i915_engine_info {
 	__u64 rsvd1[4];
 };
 
+/**
+ * struct drm_i915_query_cs_cycles
+ *
+ * The query returns the command streamer cycles and the frequency that can be
+ * used to calculate the command streamer timestamp. In addition the query
+ * returns a set of cpu timestamps that indicate when the command streamer cycle
+ * count was captured.
+ */
+struct drm_i915_query_cs_cycles {
+	/** Engine for which command streamer cycles is queried. */
+	struct i915_engine_class_instance engine;
+
+	/** Must be zero. */
+	__u32 flags;
+
+	/**
+	 * Command streamer cycles as read from the command streamer
+	 * register at 0x358 offset.
+	 */
+	__u64 cs_cycles;
+
+	/** Frequency of the cs cycles in Hz. */
+	__u64 cs_frequency;
+
+	/**
+	 * CPU timestamp in ns. The timestamp is captured before reading the
+	 * cs_cycles register using the reference clockid set by the user.
+	 */
+	__u64 cpu_timestamp;
+
+	/**
+	 * Time delta in ns captured around reading the lower dword of the
+	 * cs_cycles register.
+	 */
+	__u64 cpu_delta;
+
+	/**
+	 * Reference clock id for CPU timestamp. For definition, see
+	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
+	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
+	 * CLOCK_TAI.
+	 */
+	__s32 clockid;
+
+	/** Must be zero. */
+	__u32 rsvd;
+};
+
 /**
  * struct drm_i915_query_engine_info
  *
-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Lionel Landwerlin]

On 29/04/2021 03:34, Umesh Nerlige Ramappa wrote:
> Perf measurements rely on CPU and engine timestamps to correlate
> events of interest across these time domains. Current mechanisms get
> these timestamps separately and the calculated delta between these
> timestamps lack enough accuracy.
>
> To improve the accuracy of these time measurements to within a few us,
> add a query that returns the engine and cpu timestamps captured as
> close to each other as possible.
>
> v2: (Tvrtko)
> - document clock reference used
> - return cpu timestamp always
> - capture cpu time just before lower dword of cs timestamp
>
> v3: (Chris)
> - use uncore-rpm
> - use __query_cs_timestamp helper
>
> v4: (Lionel)
> - Kernel perf subsytem allows users to specify the clock id to be used
>    in perf_event_open. This clock id is used by the perf subsystem to
>    return the appropriate cpu timestamp in perf events. Similarly, let
>    the user pass the clockid to this query so that cpu timestamp
>    corresponds to the clock id requested.
>
> v5: (Tvrtko)
> - Use normal ktime accessors instead of fast versions
> - Add more uApi documentation
>
> v6: (Lionel)
> - Move switch out of spinlock
>
> v7: (Chris)
> - cs_timestamp is a misnomer, use cs_cycles instead
> - return the cs cycle frequency as well in the query
>
> v8:
> - Add platform and engine specific checks
>
> v9: (Lionel)
> - Return 2 cpu timestamps in the query - captured before and after the
>    register read
>
> v10: (Chris)
> - Use local_clock() to measure time taken to read lower dword of
>    register and return it to user.
>
> v11: (Jani)
> - IS_GEN deprecated. User GRAPHICS_VER instead.
>
> v12: (Jason)
> - Split cpu timestamp array into timestamp and delta for cleaner API
>
> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>


Thanks for the update :


Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>


> ---
>   drivers/gpu/drm/i915/i915_query.c | 148 ++++++++++++++++++++++++++++++
>   include/uapi/drm/i915_drm.h       |  52 +++++++++++
>   2 files changed, 200 insertions(+)
>
> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> index fed337ad7b68..357c44e8177c 100644
> --- a/drivers/gpu/drm/i915/i915_query.c
> +++ b/drivers/gpu/drm/i915/i915_query.c
> @@ -6,6 +6,8 @@
>   
>   #include <linux/nospec.h>
>   
> +#include "gt/intel_engine_pm.h"
> +#include "gt/intel_engine_user.h"
>   #include "i915_drv.h"
>   #include "i915_perf.h"
>   #include "i915_query.h"
> @@ -90,6 +92,151 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>   	return total_length;
>   }
>   
> +typedef u64 (*__ktime_func_t)(void);
> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> +{
> +	/*
> +	 * Use logic same as the perf subsystem to allow user to select the
> +	 * reference clock id to be used for timestamps.
> +	 */
> +	switch (clk_id) {
> +	case CLOCK_MONOTONIC:
> +		return &ktime_get_ns;
> +	case CLOCK_MONOTONIC_RAW:
> +		return &ktime_get_raw_ns;
> +	case CLOCK_REALTIME:
> +		return &ktime_get_real_ns;
> +	case CLOCK_BOOTTIME:
> +		return &ktime_get_boottime_ns;
> +	case CLOCK_TAI:
> +		return &ktime_get_clocktai_ns;
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static inline int
> +__read_timestamps(struct intel_uncore *uncore,
> +		  i915_reg_t lower_reg,
> +		  i915_reg_t upper_reg,
> +		  u64 *cs_ts,
> +		  u64 *cpu_ts,
> +		  u64 *cpu_delta,
> +		  __ktime_func_t cpu_clock)
> +{
> +	u32 upper, lower, old_upper, loop = 0;
> +
> +	upper = intel_uncore_read_fw(uncore, upper_reg);
> +	do {
> +		*cpu_delta = local_clock();
> +		*cpu_ts = cpu_clock();
> +		lower = intel_uncore_read_fw(uncore, lower_reg);
> +		*cpu_delta = local_clock() - *cpu_delta;
> +		old_upper = upper;
> +		upper = intel_uncore_read_fw(uncore, upper_reg);
> +	} while (upper != old_upper && loop++ < 2);
> +
> +	*cs_ts = (u64)upper << 32 | lower;
> +
> +	return 0;
> +}
> +
> +static int
> +__query_cs_cycles(struct intel_engine_cs *engine,
> +		  u64 *cs_ts, u64 *cpu_ts, u64 *cpu_delta,
> +		  __ktime_func_t cpu_clock)
> +{
> +	struct intel_uncore *uncore = engine->uncore;
> +	enum forcewake_domains fw_domains;
> +	u32 base = engine->mmio_base;
> +	intel_wakeref_t wakeref;
> +	int ret;
> +
> +	fw_domains = intel_uncore_forcewake_for_reg(uncore,
> +						    RING_TIMESTAMP(base),
> +						    FW_REG_READ);
> +
> +	with_intel_runtime_pm(uncore->rpm, wakeref) {
> +		spin_lock_irq(&uncore->lock);
> +		intel_uncore_forcewake_get__locked(uncore, fw_domains);
> +
> +		ret = __read_timestamps(uncore,
> +					RING_TIMESTAMP(base),
> +					RING_TIMESTAMP_UDW(base),
> +					cs_ts,
> +					cpu_ts,
> +					cpu_delta,
> +					cpu_clock);
> +
> +		intel_uncore_forcewake_put__locked(uncore, fw_domains);
> +		spin_unlock_irq(&uncore->lock);
> +	}
> +
> +	return ret;
> +}
> +
> +static int
> +query_cs_cycles(struct drm_i915_private *i915,
> +		struct drm_i915_query_item *query_item)
> +{
> +	struct drm_i915_query_cs_cycles __user *query_ptr;
> +	struct drm_i915_query_cs_cycles query;
> +	struct intel_engine_cs *engine;
> +	__ktime_func_t cpu_clock;
> +	int ret;
> +
> +	if (GRAPHICS_VER(i915) < 6)
> +		return -ENODEV;
> +
> +	query_ptr = u64_to_user_ptr(query_item->data_ptr);
> +	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> +	if (ret != 0)
> +		return ret;
> +
> +	if (query.flags)
> +		return -EINVAL;
> +
> +	if (query.rsvd)
> +		return -EINVAL;
> +
> +	cpu_clock = __clock_id_to_func(query.clockid);
> +	if (!cpu_clock)
> +		return -EINVAL;
> +
> +	engine = intel_engine_lookup_user(i915,
> +					  query.engine.engine_class,
> +					  query.engine.engine_instance);
> +	if (!engine)
> +		return -EINVAL;
> +
> +	if (GRAPHICS_VER(i915) == 6 &&
> +	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> +		return -ENODEV;
> +
> +	query.cs_frequency = engine->gt->clock_frequency;
> +	ret = __query_cs_cycles(engine,
> +				&query.cs_cycles,
> +				&query.cpu_timestamp,
> +				&query.cpu_delta,
> +				cpu_clock);
> +	if (ret)
> +		return ret;
> +
> +	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> +		return -EFAULT;
> +
> +	if (put_user(query.cpu_timestamp, &query_ptr->cpu_timestamp))
> +		return -EFAULT;
> +
> +	if (put_user(query.cpu_delta, &query_ptr->cpu_delta))
> +		return -EFAULT;
> +
> +	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> +		return -EFAULT;
> +
> +	return sizeof(query);
> +}
> +
>   static int
>   query_engine_info(struct drm_i915_private *i915,
>   		  struct drm_i915_query_item *query_item)
> @@ -424,6 +571,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>   	query_topology_info,
>   	query_engine_info,
>   	query_perf_config,
> +	query_cs_cycles,
>   };
>   
>   int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> index 6a34243a7646..0b4c27092d41 100644
> --- a/include/uapi/drm/i915_drm.h
> +++ b/include/uapi/drm/i915_drm.h
> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>   #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>   #define DRM_I915_QUERY_ENGINE_INFO	2
>   #define DRM_I915_QUERY_PERF_CONFIG      3
> +	/**
> +	 * Query Command Streamer timestamp register.
> +	 */
> +#define DRM_I915_QUERY_CS_CYCLES	4
>   /* Must be kept compact -- no holes and well documented */
>   
>   	/**
> @@ -2397,6 +2401,54 @@ struct drm_i915_engine_info {
>   	__u64 rsvd1[4];
>   };
>   
> +/**
> + * struct drm_i915_query_cs_cycles
> + *
> + * The query returns the command streamer cycles and the frequency that can be
> + * used to calculate the command streamer timestamp. In addition the query
> + * returns a set of cpu timestamps that indicate when the command streamer cycle
> + * count was captured.
> + */
> +struct drm_i915_query_cs_cycles {
> +	/** Engine for which command streamer cycles is queried. */
> +	struct i915_engine_class_instance engine;
> +
> +	/** Must be zero. */
> +	__u32 flags;
> +
> +	/**
> +	 * Command streamer cycles as read from the command streamer
> +	 * register at 0x358 offset.
> +	 */
> +	__u64 cs_cycles;
> +
> +	/** Frequency of the cs cycles in Hz. */
> +	__u64 cs_frequency;
> +
> +	/**
> +	 * CPU timestamp in ns. The timestamp is captured before reading the
> +	 * cs_cycles register using the reference clockid set by the user.
> +	 */
> +	__u64 cpu_timestamp;
> +
> +	/**
> +	 * Time delta in ns captured around reading the lower dword of the
> +	 * cs_cycles register.
> +	 */
> +	__u64 cpu_delta;
> +
> +	/**
> +	 * Reference clock id for CPU timestamp. For definition, see
> +	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> +	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> +	 * CLOCK_TAI.
> +	 */
> +	__s32 clockid;
> +
> +	/** Must be zero. */
> +	__u32 rsvd;
> +};
> +
>   /**
>    * struct drm_i915_query_engine_info
>    *


_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jason Ekstrand]

On Wed, Apr 28, 2021 at 7:34 PM Umesh Nerlige Ramappa
<umesh.nerlige.ramappa@intel.com> wrote:
>
> Perf measurements rely on CPU and engine timestamps to correlate
> events of interest across these time domains. Current mechanisms get
> these timestamps separately and the calculated delta between these
> timestamps lack enough accuracy.
>
> To improve the accuracy of these time measurements to within a few us,
> add a query that returns the engine and cpu timestamps captured as
> close to each other as possible.
>
> v2: (Tvrtko)
> - document clock reference used
> - return cpu timestamp always
> - capture cpu time just before lower dword of cs timestamp
>
> v3: (Chris)
> - use uncore-rpm
> - use __query_cs_timestamp helper
>
> v4: (Lionel)
> - Kernel perf subsytem allows users to specify the clock id to be used
>   in perf_event_open. This clock id is used by the perf subsystem to
>   return the appropriate cpu timestamp in perf events. Similarly, let
>   the user pass the clockid to this query so that cpu timestamp
>   corresponds to the clock id requested.
>
> v5: (Tvrtko)
> - Use normal ktime accessors instead of fast versions
> - Add more uApi documentation
>
> v6: (Lionel)
> - Move switch out of spinlock
>
> v7: (Chris)
> - cs_timestamp is a misnomer, use cs_cycles instead
> - return the cs cycle frequency as well in the query
>
> v8:
> - Add platform and engine specific checks
>
> v9: (Lionel)
> - Return 2 cpu timestamps in the query - captured before and after the
>   register read
>
> v10: (Chris)
> - Use local_clock() to measure time taken to read lower dword of
>   register and return it to user.
>
> v11: (Jani)
> - IS_GEN deprecated. User GRAPHICS_VER instead.
>
> v12: (Jason)
> - Split cpu timestamp array into timestamp and delta for cleaner API
>
> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
> ---
>  drivers/gpu/drm/i915/i915_query.c | 148 ++++++++++++++++++++++++++++++
>  include/uapi/drm/i915_drm.h       |  52 +++++++++++
>  2 files changed, 200 insertions(+)
>
> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> index fed337ad7b68..357c44e8177c 100644
> --- a/drivers/gpu/drm/i915/i915_query.c
> +++ b/drivers/gpu/drm/i915/i915_query.c
> @@ -6,6 +6,8 @@
>
>  #include <linux/nospec.h>
>
> +#include "gt/intel_engine_pm.h"
> +#include "gt/intel_engine_user.h"
>  #include "i915_drv.h"
>  #include "i915_perf.h"
>  #include "i915_query.h"
> @@ -90,6 +92,151 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>         return total_length;
>  }
>
> +typedef u64 (*__ktime_func_t)(void);
> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> +{
> +       /*
> +        * Use logic same as the perf subsystem to allow user to select the
> +        * reference clock id to be used for timestamps.
> +        */
> +       switch (clk_id) {
> +       case CLOCK_MONOTONIC:
> +               return &ktime_get_ns;
> +       case CLOCK_MONOTONIC_RAW:
> +               return &ktime_get_raw_ns;
> +       case CLOCK_REALTIME:
> +               return &ktime_get_real_ns;
> +       case CLOCK_BOOTTIME:
> +               return &ktime_get_boottime_ns;
> +       case CLOCK_TAI:
> +               return &ktime_get_clocktai_ns;
> +       default:
> +               return NULL;
> +       }
> +}
> +
> +static inline int
> +__read_timestamps(struct intel_uncore *uncore,
> +                 i915_reg_t lower_reg,
> +                 i915_reg_t upper_reg,
> +                 u64 *cs_ts,
> +                 u64 *cpu_ts,
> +                 u64 *cpu_delta,
> +                 __ktime_func_t cpu_clock)
> +{
> +       u32 upper, lower, old_upper, loop = 0;
> +
> +       upper = intel_uncore_read_fw(uncore, upper_reg);
> +       do {
> +               *cpu_delta = local_clock();
> +               *cpu_ts = cpu_clock();
> +               lower = intel_uncore_read_fw(uncore, lower_reg);
> +               *cpu_delta = local_clock() - *cpu_delta;
> +               old_upper = upper;
> +               upper = intel_uncore_read_fw(uncore, upper_reg);
> +       } while (upper != old_upper && loop++ < 2);
> +
> +       *cs_ts = (u64)upper << 32 | lower;
> +
> +       return 0;
> +}
> +
> +static int
> +__query_cs_cycles(struct intel_engine_cs *engine,
> +                 u64 *cs_ts, u64 *cpu_ts, u64 *cpu_delta,
> +                 __ktime_func_t cpu_clock)
> +{
> +       struct intel_uncore *uncore = engine->uncore;
> +       enum forcewake_domains fw_domains;
> +       u32 base = engine->mmio_base;
> +       intel_wakeref_t wakeref;
> +       int ret;
> +
> +       fw_domains = intel_uncore_forcewake_for_reg(uncore,
> +                                                   RING_TIMESTAMP(base),
> +                                                   FW_REG_READ);
> +
> +       with_intel_runtime_pm(uncore->rpm, wakeref) {
> +               spin_lock_irq(&uncore->lock);
> +               intel_uncore_forcewake_get__locked(uncore, fw_domains);
> +
> +               ret = __read_timestamps(uncore,
> +                                       RING_TIMESTAMP(base),
> +                                       RING_TIMESTAMP_UDW(base),
> +                                       cs_ts,
> +                                       cpu_ts,
> +                                       cpu_delta,
> +                                       cpu_clock);
> +
> +               intel_uncore_forcewake_put__locked(uncore, fw_domains);
> +               spin_unlock_irq(&uncore->lock);
> +       }
> +
> +       return ret;
> +}
> +
> +static int
> +query_cs_cycles(struct drm_i915_private *i915,
> +               struct drm_i915_query_item *query_item)
> +{
> +       struct drm_i915_query_cs_cycles __user *query_ptr;
> +       struct drm_i915_query_cs_cycles query;
> +       struct intel_engine_cs *engine;
> +       __ktime_func_t cpu_clock;
> +       int ret;
> +
> +       if (GRAPHICS_VER(i915) < 6)
> +               return -ENODEV;
> +
> +       query_ptr = u64_to_user_ptr(query_item->data_ptr);
> +       ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> +       if (ret != 0)
> +               return ret;
> +
> +       if (query.flags)
> +               return -EINVAL;
> +
> +       if (query.rsvd)
> +               return -EINVAL;
> +
> +       cpu_clock = __clock_id_to_func(query.clockid);
> +       if (!cpu_clock)
> +               return -EINVAL;
> +
> +       engine = intel_engine_lookup_user(i915,
> +                                         query.engine.engine_class,
> +                                         query.engine.engine_instance);
> +       if (!engine)
> +               return -EINVAL;
> +
> +       if (GRAPHICS_VER(i915) == 6 &&
> +           query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> +               return -ENODEV;
> +
> +       query.cs_frequency = engine->gt->clock_frequency;
> +       ret = __query_cs_cycles(engine,
> +                               &query.cs_cycles,
> +                               &query.cpu_timestamp,
> +                               &query.cpu_delta,
> +                               cpu_clock);
> +       if (ret)
> +               return ret;
> +
> +       if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> +               return -EFAULT;
> +
> +       if (put_user(query.cpu_timestamp, &query_ptr->cpu_timestamp))
> +               return -EFAULT;
> +
> +       if (put_user(query.cpu_delta, &query_ptr->cpu_delta))
> +               return -EFAULT;
> +
> +       if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> +               return -EFAULT;
> +
> +       return sizeof(query);
> +}
> +
>  static int
>  query_engine_info(struct drm_i915_private *i915,
>                   struct drm_i915_query_item *query_item)
> @@ -424,6 +571,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>         query_topology_info,
>         query_engine_info,
>         query_perf_config,
> +       query_cs_cycles,
>  };
>
>  int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> index 6a34243a7646..0b4c27092d41 100644
> --- a/include/uapi/drm/i915_drm.h
> +++ b/include/uapi/drm/i915_drm.h
> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>  #define DRM_I915_QUERY_ENGINE_INFO     2
>  #define DRM_I915_QUERY_PERF_CONFIG      3
> +       /**
> +        * Query Command Streamer timestamp register.
> +        */
> +#define DRM_I915_QUERY_CS_CYCLES       4
>  /* Must be kept compact -- no holes and well documented */
>
>         /**
> @@ -2397,6 +2401,54 @@ struct drm_i915_engine_info {
>         __u64 rsvd1[4];
>  };
>
> +/**
> + * struct drm_i915_query_cs_cycles
> + *
> + * The query returns the command streamer cycles and the frequency that can be
> + * used to calculate the command streamer timestamp. In addition the query
> + * returns a set of cpu timestamps that indicate when the command streamer cycle
> + * count was captured.
> + */
> +struct drm_i915_query_cs_cycles {
> +       /** Engine for which command streamer cycles is queried. */
> +       struct i915_engine_class_instance engine;

I've checked with HW engineers and they're claiming that all CS
timestamp registers should report the same time modulo minor drift.
You're CC'd on the internal e-mail.  If this is really the case, then
I don't think we want to put an engine in this query.

--Jason

> +
> +       /** Must be zero. */
> +       __u32 flags;
> +
> +       /**
> +        * Command streamer cycles as read from the command streamer
> +        * register at 0x358 offset.
> +        */
> +       __u64 cs_cycles;
> +
> +       /** Frequency of the cs cycles in Hz. */
> +       __u64 cs_frequency;
> +
> +       /**
> +        * CPU timestamp in ns. The timestamp is captured before reading the
> +        * cs_cycles register using the reference clockid set by the user.
> +        */
> +       __u64 cpu_timestamp;
> +
> +       /**
> +        * Time delta in ns captured around reading the lower dword of the
> +        * cs_cycles register.
> +        */
> +       __u64 cpu_delta;
> +
> +       /**
> +        * Reference clock id for CPU timestamp. For definition, see
> +        * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> +        * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> +        * CLOCK_TAI.
> +        */
> +       __s32 clockid;
> +
> +       /** Must be zero. */
> +       __u32 rsvd;
> +};
> +
>  /**
>   * struct drm_i915_query_engine_info
>   *
> --
> 2.20.1
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

On Thu, Apr 29, 2021 at 02:07:58PM -0500, Jason Ekstrand wrote:
>On Wed, Apr 28, 2021 at 7:34 PM Umesh Nerlige Ramappa
><umesh.nerlige.ramappa@intel.com> wrote:
>>
>> Perf measurements rely on CPU and engine timestamps to correlate
>> events of interest across these time domains. Current mechanisms get
>> these timestamps separately and the calculated delta between these
>> timestamps lack enough accuracy.
>>
>> To improve the accuracy of these time measurements to within a few us,
>> add a query that returns the engine and cpu timestamps captured as
>> close to each other as possible.
>>
>> v2: (Tvrtko)
>> - document clock reference used
>> - return cpu timestamp always
>> - capture cpu time just before lower dword of cs timestamp
>>
>> v3: (Chris)
>> - use uncore-rpm
>> - use __query_cs_timestamp helper
>>
>> v4: (Lionel)
>> - Kernel perf subsytem allows users to specify the clock id to be used
>>   in perf_event_open. This clock id is used by the perf subsystem to
>>   return the appropriate cpu timestamp in perf events. Similarly, let
>>   the user pass the clockid to this query so that cpu timestamp
>>   corresponds to the clock id requested.
>>
>> v5: (Tvrtko)
>> - Use normal ktime accessors instead of fast versions
>> - Add more uApi documentation
>>
>> v6: (Lionel)
>> - Move switch out of spinlock
>>
>> v7: (Chris)
>> - cs_timestamp is a misnomer, use cs_cycles instead
>> - return the cs cycle frequency as well in the query
>>
>> v8:
>> - Add platform and engine specific checks
>>
>> v9: (Lionel)
>> - Return 2 cpu timestamps in the query - captured before and after the
>>   register read
>>
>> v10: (Chris)
>> - Use local_clock() to measure time taken to read lower dword of
>>   register and return it to user.
>>
>> v11: (Jani)
>> - IS_GEN deprecated. User GRAPHICS_VER instead.
>>
>> v12: (Jason)
>> - Split cpu timestamp array into timestamp and delta for cleaner API
>>
>> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
>> Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
>> ---
>>  drivers/gpu/drm/i915/i915_query.c | 148 ++++++++++++++++++++++++++++++
>>  include/uapi/drm/i915_drm.h       |  52 +++++++++++
>>  2 files changed, 200 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
>> index fed337ad7b68..357c44e8177c 100644
>> --- a/drivers/gpu/drm/i915/i915_query.c
>> +++ b/drivers/gpu/drm/i915/i915_query.c
>> @@ -6,6 +6,8 @@
>>
>>  #include <linux/nospec.h>
>>
>> +#include "gt/intel_engine_pm.h"
>> +#include "gt/intel_engine_user.h"
>>  #include "i915_drv.h"
>>  #include "i915_perf.h"
>>  #include "i915_query.h"
>> @@ -90,6 +92,151 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>>         return total_length;
>>  }
>>
>> +typedef u64 (*__ktime_func_t)(void);
>> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
>> +{
>> +       /*
>> +        * Use logic same as the perf subsystem to allow user to select the
>> +        * reference clock id to be used for timestamps.
>> +        */
>> +       switch (clk_id) {
>> +       case CLOCK_MONOTONIC:
>> +               return &ktime_get_ns;
>> +       case CLOCK_MONOTONIC_RAW:
>> +               return &ktime_get_raw_ns;
>> +       case CLOCK_REALTIME:
>> +               return &ktime_get_real_ns;
>> +       case CLOCK_BOOTTIME:
>> +               return &ktime_get_boottime_ns;
>> +       case CLOCK_TAI:
>> +               return &ktime_get_clocktai_ns;
>> +       default:
>> +               return NULL;
>> +       }
>> +}
>> +
>> +static inline int
>> +__read_timestamps(struct intel_uncore *uncore,
>> +                 i915_reg_t lower_reg,
>> +                 i915_reg_t upper_reg,
>> +                 u64 *cs_ts,
>> +                 u64 *cpu_ts,
>> +                 u64 *cpu_delta,
>> +                 __ktime_func_t cpu_clock)
>> +{
>> +       u32 upper, lower, old_upper, loop = 0;
>> +
>> +       upper = intel_uncore_read_fw(uncore, upper_reg);
>> +       do {
>> +               *cpu_delta = local_clock();
>> +               *cpu_ts = cpu_clock();
>> +               lower = intel_uncore_read_fw(uncore, lower_reg);
>> +               *cpu_delta = local_clock() - *cpu_delta;
>> +               old_upper = upper;
>> +               upper = intel_uncore_read_fw(uncore, upper_reg);
>> +       } while (upper != old_upper && loop++ < 2);
>> +
>> +       *cs_ts = (u64)upper << 32 | lower;
>> +
>> +       return 0;
>> +}
>> +
>> +static int
>> +__query_cs_cycles(struct intel_engine_cs *engine,
>> +                 u64 *cs_ts, u64 *cpu_ts, u64 *cpu_delta,
>> +                 __ktime_func_t cpu_clock)
>> +{
>> +       struct intel_uncore *uncore = engine->uncore;
>> +       enum forcewake_domains fw_domains;
>> +       u32 base = engine->mmio_base;
>> +       intel_wakeref_t wakeref;
>> +       int ret;
>> +
>> +       fw_domains = intel_uncore_forcewake_for_reg(uncore,
>> +                                                   RING_TIMESTAMP(base),
>> +                                                   FW_REG_READ);
>> +
>> +       with_intel_runtime_pm(uncore->rpm, wakeref) {
>> +               spin_lock_irq(&uncore->lock);
>> +               intel_uncore_forcewake_get__locked(uncore, fw_domains);
>> +
>> +               ret = __read_timestamps(uncore,
>> +                                       RING_TIMESTAMP(base),
>> +                                       RING_TIMESTAMP_UDW(base),
>> +                                       cs_ts,
>> +                                       cpu_ts,
>> +                                       cpu_delta,
>> +                                       cpu_clock);
>> +
>> +               intel_uncore_forcewake_put__locked(uncore, fw_domains);
>> +               spin_unlock_irq(&uncore->lock);
>> +       }
>> +
>> +       return ret;
>> +}
>> +
>> +static int
>> +query_cs_cycles(struct drm_i915_private *i915,
>> +               struct drm_i915_query_item *query_item)
>> +{
>> +       struct drm_i915_query_cs_cycles __user *query_ptr;
>> +       struct drm_i915_query_cs_cycles query;
>> +       struct intel_engine_cs *engine;
>> +       __ktime_func_t cpu_clock;
>> +       int ret;
>> +
>> +       if (GRAPHICS_VER(i915) < 6)
>> +               return -ENODEV;
>> +
>> +       query_ptr = u64_to_user_ptr(query_item->data_ptr);
>> +       ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
>> +       if (ret != 0)
>> +               return ret;
>> +
>> +       if (query.flags)
>> +               return -EINVAL;
>> +
>> +       if (query.rsvd)
>> +               return -EINVAL;
>> +
>> +       cpu_clock = __clock_id_to_func(query.clockid);
>> +       if (!cpu_clock)
>> +               return -EINVAL;
>> +
>> +       engine = intel_engine_lookup_user(i915,
>> +                                         query.engine.engine_class,
>> +                                         query.engine.engine_instance);
>> +       if (!engine)
>> +               return -EINVAL;
>> +
>> +       if (GRAPHICS_VER(i915) == 6 &&
>> +           query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>> +               return -ENODEV;
>> +
>> +       query.cs_frequency = engine->gt->clock_frequency;
>> +       ret = __query_cs_cycles(engine,
>> +                               &query.cs_cycles,
>> +                               &query.cpu_timestamp,
>> +                               &query.cpu_delta,
>> +                               cpu_clock);
>> +       if (ret)
>> +               return ret;
>> +
>> +       if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
>> +               return -EFAULT;
>> +
>> +       if (put_user(query.cpu_timestamp, &query_ptr->cpu_timestamp))
>> +               return -EFAULT;
>> +
>> +       if (put_user(query.cpu_delta, &query_ptr->cpu_delta))
>> +               return -EFAULT;
>> +
>> +       if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
>> +               return -EFAULT;
>> +
>> +       return sizeof(query);
>> +}
>> +
>>  static int
>>  query_engine_info(struct drm_i915_private *i915,
>>                   struct drm_i915_query_item *query_item)
>> @@ -424,6 +571,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>>         query_topology_info,
>>         query_engine_info,
>>         query_perf_config,
>> +       query_cs_cycles,
>>  };
>>
>>  int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
>> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
>> index 6a34243a7646..0b4c27092d41 100644
>> --- a/include/uapi/drm/i915_drm.h
>> +++ b/include/uapi/drm/i915_drm.h
>> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>>  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>>  #define DRM_I915_QUERY_ENGINE_INFO     2
>>  #define DRM_I915_QUERY_PERF_CONFIG      3
>> +       /**
>> +        * Query Command Streamer timestamp register.
>> +        */
>> +#define DRM_I915_QUERY_CS_CYCLES       4
>>  /* Must be kept compact -- no holes and well documented */
>>
>>         /**
>> @@ -2397,6 +2401,54 @@ struct drm_i915_engine_info {
>>         __u64 rsvd1[4];
>>  };
>>
>> +/**
>> + * struct drm_i915_query_cs_cycles
>> + *
>> + * The query returns the command streamer cycles and the frequency that can be
>> + * used to calculate the command streamer timestamp. In addition the query
>> + * returns a set of cpu timestamps that indicate when the command streamer cycle
>> + * count was captured.
>> + */
>> +struct drm_i915_query_cs_cycles {
>> +       /** Engine for which command streamer cycles is queried. */
>> +       struct i915_engine_class_instance engine;
>
>I've checked with HW engineers and they're claiming that all CS
>timestamp registers should report the same time modulo minor drift.
>You're CC'd on the internal e-mail.  If this is really the case, then
>I don't think we want to put an engine in this query.

Looks like the engine can be dropped since all timestamps are in sync. I 
just have one more question here. The timestamp itself is 36 bits.  
Should the uapi also report the timestamp width to the user OR should I 
just return the lower 32 bits of the timestamp?

Thanks,
Umesh

>
>--Jason
>
>> +
>> +       /** Must be zero. */
>> +       __u32 flags;
>> +
>> +       /**
>> +        * Command streamer cycles as read from the command streamer
>> +        * register at 0x358 offset.
>> +        */
>> +       __u64 cs_cycles;
>> +
>> +       /** Frequency of the cs cycles in Hz. */
>> +       __u64 cs_frequency;
>> +
>> +       /**
>> +        * CPU timestamp in ns. The timestamp is captured before reading the
>> +        * cs_cycles register using the reference clockid set by the user.
>> +        */
>> +       __u64 cpu_timestamp;
>> +
>> +       /**
>> +        * Time delta in ns captured around reading the lower dword of the
>> +        * cs_cycles register.
>> +        */
>> +       __u64 cpu_delta;
>> +
>> +       /**
>> +        * Reference clock id for CPU timestamp. For definition, see
>> +        * clock_gettime(2) and perf_event_open(2). Supported clock ids are
>> +        * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
>> +        * CLOCK_TAI.
>> +        */
>> +       __s32 clockid;
>> +
>> +       /** Must be zero. */
>> +       __u32 rsvd;
>> +};
>> +
>>  /**
>>   * struct drm_i915_query_engine_info
>>   *
>> --
>> 2.20.1
>>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Dixit, Ashutosh]

On Fri, 30 Apr 2021 15:26:09 -0700, Umesh Nerlige Ramappa wrote:
>
> Looks like the engine can be dropped since all timestamps are in sync. I
> just have one more question here. The timestamp itself is 36 bits.  Should
> the uapi also report the timestamp width to the user OR should I just
> return the lower 32 bits of the timestamp?

How would exposing only the lower 32 bits of the timestamp work?

The way to avoid exposing the width would be to expose the timestamp as a
regular 64 bit value. In the kernel engine state, have a variable for the
counter and keep on accumulating that (on each query) to full 64 bits in
spite of the 36 bit HW counter overflow.

So not exposing the width (or exposing a 64 bit timestamp) is a cleaner
interface but also more work in the kernel.
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Dixit, Ashutosh]

On Fri, 30 Apr 2021 16:00:46 -0700, Dixit, Ashutosh wrote:
>
> On Fri, 30 Apr 2021 15:26:09 -0700, Umesh Nerlige Ramappa wrote:
> >
> > Looks like the engine can be dropped since all timestamps are in sync. I
> > just have one more question here. The timestamp itself is 36 bits.  Should
> > the uapi also report the timestamp width to the user OR should I just
> > return the lower 32 bits of the timestamp?
>
> How would exposing only the lower 32 bits of the timestamp work?

It would work I guess but overflow every few seconds. So if the counters
are sampled at a low frequency (once every few seconds) it would yield
misleading timestamps.

> The way to avoid exposing the width would be to expose the timestamp as a
> regular 64 bit value. In the kernel engine state, have a variable for the
> counter and keep on accumulating that (on each query) to full 64 bits in
> spite of the 36 bit HW counter overflow.
>
> So not exposing the width (or exposing a 64 bit timestamp) is a cleaner
> interface but also more work in the kernel.
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jason Ekstrand]

[-- Attachment #1.1: Type: text/plain, Size: 1105 bytes --]

On April 30, 2021 18:00:58 "Dixit, Ashutosh" <ashutosh.dixit@intel.com> wrote:

> On Fri, 30 Apr 2021 15:26:09 -0700, Umesh Nerlige Ramappa wrote:
>>
>> Looks like the engine can be dropped since all timestamps are in sync. I
>> just have one more question here. The timestamp itself is 36 bits.  Should
>> the uapi also report the timestamp width to the user OR should I just
>> return the lower 32 bits of the timestamp?

Yeah, I think reporting the timestamp width is a good idea since we're 
reporting the period/frequency here.

>>
> How would exposing only the lower 32 bits of the timestamp work?
>
> The way to avoid exposing the width would be to expose the timestamp as a
> regular 64 bit value. In the kernel engine state, have a variable for the
> counter and keep on accumulating that (on each query) to full 64 bits in
> spite of the 36 bit HW counter overflow.

That's doesn't actually work since you can query the 64-bit timestamp value 
from the GPU. The way this is handled in Vulkan is that the number of 
timestamp bits is reported to the application as a queue property.

--Jason
>



[-- Attachment #1.2: Type: text/html, Size: 2701 bytes --]

[-- Attachment #2: Type: text/plain, Size: 160 bytes --]

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

On Fri, Apr 30, 2021 at 07:35:41PM -0500, Jason Ekstrand wrote:
>   On April 30, 2021 18:00:58 "Dixit, Ashutosh" <ashutosh.dixit@intel.com>
>   wrote:
>
>     On Fri, 30 Apr 2021 15:26:09 -0700, Umesh Nerlige Ramappa wrote:
>
>       Looks like the engine can be dropped since all timestamps are in sync.
>       I
>       just have one more question here. The timestamp itself is 36 bits.
>        Should
>       the uapi also report the timestamp width to the user OR should I just
>       return the lower 32 bits of the timestamp?
>
>   Yeah, I think reporting the timestamp width is a good idea since we're
>   reporting the period/frequency here.

Actually, I forgot that we are handling the overflow before returning 
the cs_cycles to the user and overflow handling was the only reason I 
thought user should know the width. Would you stil recommend returning 
the width in the uapi?

Thanks,
Umesh


>
>     How would exposing only the lower 32 bits of the timestamp work?
>     The way to avoid exposing the width would be to expose the timestamp as
>     a
>     regular 64 bit value. In the kernel engine state, have a variable for
>     the
>     counter and keep on accumulating that (on each query) to full 64 bits in
>     spite of the 36 bit HW counter overflow.
>
>   That's doesn't actually work since you can query the 64-bit timestamp
>   value from the GPU. The way this is handled in Vulkan is that the number
>   of timestamp bits is reported to the application as a queue property.
>   --Jason
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Dixit, Ashutosh]

On Fri, 30 Apr 2021 19:19:59 -0700, Umesh Nerlige Ramappa wrote:
>
> On Fri, Apr 30, 2021 at 07:35:41PM -0500, Jason Ekstrand wrote:
> >   On April 30, 2021 18:00:58 "Dixit, Ashutosh" <ashutosh.dixit@intel.com>
> >   wrote:
> >
> >     On Fri, 30 Apr 2021 15:26:09 -0700, Umesh Nerlige Ramappa wrote:
> >
> >       Looks like the engine can be dropped since all timestamps are in sync.
> >       I
> >       just have one more question here. The timestamp itself is 36 bits.
> >        Should
> >       the uapi also report the timestamp width to the user OR should I just
> >       return the lower 32 bits of the timestamp?
> >
> >   Yeah, I think reporting the timestamp width is a good idea since we're
> >   reporting the period/frequency here.
>
> Actually, I forgot that we are handling the overflow before returning the
> cs_cycles to the user and overflow handling was the only reason I thought
> user should know the width. Would you stil recommend returning the width in
> the uapi?

The width is needed for userspace to figure out if overflow has occured
between two successive query calls. I don't think I see this happening in
the code.
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jason Ekstrand]

[-- Attachment #1.1: Type: text/plain, Size: 2309 bytes --]

On April 30, 2021 23:01:44 "Dixit, Ashutosh" <ashutosh.dixit@intel.com> wrote:
> On Fri, 30 Apr 2021 19:19:59 -0700, Umesh Nerlige Ramappa wrote:
>>
>> On Fri, Apr 30, 2021 at 07:35:41PM -0500, Jason Ekstrand wrote:
>>> On April 30, 2021 18:00:58 "Dixit, Ashutosh" <ashutosh.dixit@intel.com>
>>> wrote:
>>>
>>> On Fri, 30 Apr 2021 15:26:09 -0700, Umesh Nerlige Ramappa wrote:
>>>
>>> Looks like the engine can be dropped since all timestamps are in sync.
>>> I
>>> just have one more question here. The timestamp itself is 36 bits.
>>> Should
>>> the uapi also report the timestamp width to the user OR should I just
>>> return the lower 32 bits of the timestamp?
>>>
>>> Yeah, I think reporting the timestamp width is a good idea since we're
>>> reporting the period/frequency here.
>>
>> Actually, I forgot that we are handling the overflow before returning the
>> cs_cycles to the user and overflow handling was the only reason I thought
>> user should know the width. Would you stil recommend returning the width in
>> the uapi?
>
> The width is needed for userspace to figure out if overflow has occured
> between two successive query calls. I don't think I see this happening in
> the code.

Right... We (UMDs) currently just hard-code it to 36 bits because that's 
what we've had on all platforms since close enough to forever. We bake in 
the frequency based on PCI ID. Returning the number of bits, like I said, 
goes nicely with the frequency. It's not necessary, assuming sufficiently 
smart userspace (neither is frequency), but it seems to go with it. I guess 
I don't care much either way.

Coming back to the multi-tile issue we discussed internally, I think that 
is something we should care about. Since this works by reading the 
timestamp register on an engine, I think leaving the engine specifier in 
there is fine. Userspace should know that there's actually only one clock 
and just query one of them (probably RCS). For crazy multi-device cases, 
we'll either query per logical device (read tile) or we'll have to make 
them look like a single device and sync the timestamps somehow in the UMD 
by carrying around an offset factor.

As is, this patch is

Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>

I still need to review the ANV patch before we can land this though.

--Jason

[-- Attachment #1.2: Type: text/html, Size: 3849 bytes --]

[-- Attachment #2: Type: text/plain, Size: 160 bytes --]

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

On Sat, May 01, 2021 at 10:27:03AM -0500, Jason Ekstrand wrote:
>   On April 30, 2021 23:01:44 "Dixit, Ashutosh" <ashutosh.dixit@intel.com>
>   wrote:
>
>     On Fri, 30 Apr 2021 19:19:59 -0700, Umesh Nerlige Ramappa wrote:
>
>       On Fri, Apr 30, 2021 at 07:35:41PM -0500, Jason Ekstrand wrote:
>
>         On April 30, 2021 18:00:58 "Dixit, Ashutosh"
>         <ashutosh.dixit@intel.com>
>         wrote:
>         On Fri, 30 Apr 2021 15:26:09 -0700, Umesh Nerlige Ramappa wrote:
>         Looks like the engine can be dropped since all timestamps are in
>         sync.
>         I
>         just have one more question here. The timestamp itself is 36 bits.
>          Should
>         the uapi also report the timestamp width to the user OR should I
>         just
>         return the lower 32 bits of the timestamp?
>         Yeah, I think reporting the timestamp width is a good idea since
>         we're
>         reporting the period/frequency here.
>
>       Actually, I forgot that we are handling the overflow before returning
>       the
>       cs_cycles to the user and overflow handling was the only reason I
>       thought
>       user should know the width. Would you stil recommend returning the
>       width in
>       the uapi?
>
>     The width is needed for userspace to figure out if overflow has occured
>     between two successive query calls. I don't think I see this happening
>     in
>     the code.
>
>   Right... We (UMDs) currently just hard-code it to 36 bits because that's
>   what we've had on all platforms since close enough to forever. We bake in
>   the frequency based on PCI ID. Returning the number of bits, like I said,
>   goes nicely with the frequency. It's not necessary, assuming sufficiently
>   smart userspace (neither is frequency), but it seems to go with it. I
>   guess I don't care much either way.
>   Coming back to the multi-tile issue we discussed internally, I think that
>   is something we should care about. Since this works by reading the
>   timestamp register on an engine, I think leaving the engine specifier in
>   there is fine. Userspace should know that there's actually only one clock
>   and just query one of them (probably RCS). For crazy multi-device cases,
>   we'll either query per logical device (read tile) or we'll have to make
>   them look like a single device and sync the timestamps somehow in the UMD
>   by carrying around an offset factor.
>   As is, this patch is
>   Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>

Thanks, I will add the width here and post the final version.

Regards,
Umesh


>   I still need to review the ANV patch before we can land this though.
>   --Jason
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 0/1] Add support for querying engine cycles

[Umesh Nerlige Ramappa]

This is just a refresh of the earlier patch along with cover letter for the IGT
testing. The query provides the engine cs cycles counter.

v2: Use GRAPHICS_VER() instead of IG_GEN()
v3: Add R-b to the patch

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Test-with: 20210421172046.65062-1-umesh.nerlige.ramappa@intel.com

Umesh Nerlige Ramappa (1):
  i915/query: Correlate engine and cpu timestamps with better accuracy

 drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  48 ++++++++++
 2 files changed, 193 insertions(+)

-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

Perf measurements rely on CPU and engine timestamps to correlate
events of interest across these time domains. Current mechanisms get
these timestamps separately and the calculated delta between these
timestamps lack enough accuracy.

To improve the accuracy of these time measurements to within a few us,
add a query that returns the engine and cpu timestamps captured as
close to each other as possible.

v2: (Tvrtko)
- document clock reference used
- return cpu timestamp always
- capture cpu time just before lower dword of cs timestamp

v3: (Chris)
- use uncore-rpm
- use __query_cs_timestamp helper

v4: (Lionel)
- Kernel perf subsytem allows users to specify the clock id to be used
  in perf_event_open. This clock id is used by the perf subsystem to
  return the appropriate cpu timestamp in perf events. Similarly, let
  the user pass the clockid to this query so that cpu timestamp
  corresponds to the clock id requested.

v5: (Tvrtko)
- Use normal ktime accessors instead of fast versions
- Add more uApi documentation

v6: (Lionel)
- Move switch out of spinlock

v7: (Chris)
- cs_timestamp is a misnomer, use cs_cycles instead
- return the cs cycle frequency as well in the query

v8:
- Add platform and engine specific checks

v9: (Lionel)
- Return 2 cpu timestamps in the query - captured before and after the
  register read

v10: (Chris)
- Use local_clock() to measure time taken to read lower dword of
  register and return it to user.

v11: (Jani)
- IS_GEN deprecated. User GRAPHICS_VER instead.

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
---
 drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  48 ++++++++++
 2 files changed, 193 insertions(+)

diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
index fed337ad7b68..2594b93901ac 100644
--- a/drivers/gpu/drm/i915/i915_query.c
+++ b/drivers/gpu/drm/i915/i915_query.c
@@ -6,6 +6,8 @@
 
 #include <linux/nospec.h>
 
+#include "gt/intel_engine_pm.h"
+#include "gt/intel_engine_user.h"
 #include "i915_drv.h"
 #include "i915_perf.h"
 #include "i915_query.h"
@@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
 	return total_length;
 }
 
+typedef u64 (*__ktime_func_t)(void);
+static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
+{
+	/*
+	 * Use logic same as the perf subsystem to allow user to select the
+	 * reference clock id to be used for timestamps.
+	 */
+	switch (clk_id) {
+	case CLOCK_MONOTONIC:
+		return &ktime_get_ns;
+	case CLOCK_MONOTONIC_RAW:
+		return &ktime_get_raw_ns;
+	case CLOCK_REALTIME:
+		return &ktime_get_real_ns;
+	case CLOCK_BOOTTIME:
+		return &ktime_get_boottime_ns;
+	case CLOCK_TAI:
+		return &ktime_get_clocktai_ns;
+	default:
+		return NULL;
+	}
+}
+
+static inline int
+__read_timestamps(struct intel_uncore *uncore,
+		  i915_reg_t lower_reg,
+		  i915_reg_t upper_reg,
+		  u64 *cs_ts,
+		  u64 *cpu_ts,
+		  __ktime_func_t cpu_clock)
+{
+	u32 upper, lower, old_upper, loop = 0;
+
+	upper = intel_uncore_read_fw(uncore, upper_reg);
+	do {
+		cpu_ts[1] = local_clock();
+		cpu_ts[0] = cpu_clock();
+		lower = intel_uncore_read_fw(uncore, lower_reg);
+		cpu_ts[1] = local_clock() - cpu_ts[1];
+		old_upper = upper;
+		upper = intel_uncore_read_fw(uncore, upper_reg);
+	} while (upper != old_upper && loop++ < 2);
+
+	*cs_ts = (u64)upper << 32 | lower;
+
+	return 0;
+}
+
+static int
+__query_cs_cycles(struct intel_engine_cs *engine,
+		  u64 *cs_ts, u64 *cpu_ts,
+		  __ktime_func_t cpu_clock)
+{
+	struct intel_uncore *uncore = engine->uncore;
+	enum forcewake_domains fw_domains;
+	u32 base = engine->mmio_base;
+	intel_wakeref_t wakeref;
+	int ret;
+
+	fw_domains = intel_uncore_forcewake_for_reg(uncore,
+						    RING_TIMESTAMP(base),
+						    FW_REG_READ);
+
+	with_intel_runtime_pm(uncore->rpm, wakeref) {
+		spin_lock_irq(&uncore->lock);
+		intel_uncore_forcewake_get__locked(uncore, fw_domains);
+
+		ret = __read_timestamps(uncore,
+					RING_TIMESTAMP(base),
+					RING_TIMESTAMP_UDW(base),
+					cs_ts,
+					cpu_ts,
+					cpu_clock);
+
+		intel_uncore_forcewake_put__locked(uncore, fw_domains);
+		spin_unlock_irq(&uncore->lock);
+	}
+
+	return ret;
+}
+
+static int
+query_cs_cycles(struct drm_i915_private *i915,
+		struct drm_i915_query_item *query_item)
+{
+	struct drm_i915_query_cs_cycles __user *query_ptr;
+	struct drm_i915_query_cs_cycles query;
+	struct intel_engine_cs *engine;
+	__ktime_func_t cpu_clock;
+	int ret;
+
+	if (GRAPHICS_VER(i915) < 6)
+		return -ENODEV;
+
+	query_ptr = u64_to_user_ptr(query_item->data_ptr);
+	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
+	if (ret != 0)
+		return ret;
+
+	if (query.flags)
+		return -EINVAL;
+
+	if (query.rsvd)
+		return -EINVAL;
+
+	cpu_clock = __clock_id_to_func(query.clockid);
+	if (!cpu_clock)
+		return -EINVAL;
+
+	engine = intel_engine_lookup_user(i915,
+					  query.engine.engine_class,
+					  query.engine.engine_instance);
+	if (!engine)
+		return -EINVAL;
+
+	if (GRAPHICS_VER(i915) == 6 &&
+	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
+		return -ENODEV;
+
+	query.cs_frequency = engine->gt->clock_frequency;
+	ret = __query_cs_cycles(engine,
+				&query.cs_cycles,
+				query.cpu_timestamp,
+				cpu_clock);
+	if (ret)
+		return ret;
+
+	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
+		return -EFAULT;
+
+	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
+		return -EFAULT;
+
+	return sizeof(query);
+}
+
 static int
 query_engine_info(struct drm_i915_private *i915,
 		  struct drm_i915_query_item *query_item)
@@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
 	query_topology_info,
 	query_engine_info,
 	query_perf_config,
+	query_cs_cycles,
 };
 
 int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
index 6a34243a7646..08b00f1709b5 100644
--- a/include/uapi/drm/i915_drm.h
+++ b/include/uapi/drm/i915_drm.h
@@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
 #define DRM_I915_QUERY_TOPOLOGY_INFO    1
 #define DRM_I915_QUERY_ENGINE_INFO	2
 #define DRM_I915_QUERY_PERF_CONFIG      3
+	/**
+	 * Query Command Streamer timestamp register.
+	 */
+#define DRM_I915_QUERY_CS_CYCLES	4
 /* Must be kept compact -- no holes and well documented */
 
 	/**
@@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
 	__u64 rsvd1[4];
 };
 
+/**
+ * struct drm_i915_query_cs_cycles
+ *
+ * The query returns the command streamer cycles and the frequency that can be
+ * used to calculate the command streamer timestamp. In addition the query
+ * returns a set of cpu timestamps that indicate when the command streamer cycle
+ * count was captured.
+ */
+struct drm_i915_query_cs_cycles {
+	/** Engine for which command streamer cycles is queried. */
+	struct i915_engine_class_instance engine;
+
+	/** Must be zero. */
+	__u32 flags;
+
+	/**
+	 * Command streamer cycles as read from the command streamer
+	 * register at 0x358 offset.
+	 */
+	__u64 cs_cycles;
+
+	/** Frequency of the cs cycles in Hz. */
+	__u64 cs_frequency;
+
+	/**
+	 * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
+	 * cs_cycles register using the reference clockid set by the user.
+	 * cpu_timestamp[1] is the time taken in ns to read the lower dword of
+	 * the cs_cycles register.
+	 */
+	__u64 cpu_timestamp[2];
+
+	/**
+	 * Reference clock id for CPU timestamp. For definition, see
+	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
+	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
+	 * CLOCK_TAI.
+	 */
+	__s32 clockid;
+
+	/** Must be zero. */
+	__u32 rsvd;
+};
+
 /**
  * struct drm_i915_query_engine_info
  *
-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 0/1] Add support for querying engine cycles

[Umesh Nerlige Ramappa]

This is just a refresh of the earlier patch along with cover letter for the IGT
testing. The query provides the engine cs cycles counter.

v2: Use GRAPHICS_VER() instead of IG_GEN()

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Test-with: 20210421172046.65062-1-umesh.nerlige.ramappa@intel.com

Umesh Nerlige Ramappa (1):
  i915/query: Correlate engine and cpu timestamps with better accuracy

 drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  48 ++++++++++
 2 files changed, 193 insertions(+)

-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

Perf measurements rely on CPU and engine timestamps to correlate
events of interest across these time domains. Current mechanisms get
these timestamps separately and the calculated delta between these
timestamps lack enough accuracy.

To improve the accuracy of these time measurements to within a few us,
add a query that returns the engine and cpu timestamps captured as
close to each other as possible.

v2: (Tvrtko)
- document clock reference used
- return cpu timestamp always
- capture cpu time just before lower dword of cs timestamp

v3: (Chris)
- use uncore-rpm
- use __query_cs_timestamp helper

v4: (Lionel)
- Kernel perf subsytem allows users to specify the clock id to be used
  in perf_event_open. This clock id is used by the perf subsystem to
  return the appropriate cpu timestamp in perf events. Similarly, let
  the user pass the clockid to this query so that cpu timestamp
  corresponds to the clock id requested.

v5: (Tvrtko)
- Use normal ktime accessors instead of fast versions
- Add more uApi documentation

v6: (Lionel)
- Move switch out of spinlock

v7: (Chris)
- cs_timestamp is a misnomer, use cs_cycles instead
- return the cs cycle frequency as well in the query

v8:
- Add platform and engine specific checks

v9: (Lionel)
- Return 2 cpu timestamps in the query - captured before and after the
  register read

v10: (Chris)
- Use local_clock() to measure time taken to read lower dword of
  register and return it to user.

v11: (Jani)
- IS_GEN deprecated. User GRAPHICS_VER instead.

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
---
 drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  48 ++++++++++
 2 files changed, 193 insertions(+)

diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
index fed337ad7b68..2594b93901ac 100644
--- a/drivers/gpu/drm/i915/i915_query.c
+++ b/drivers/gpu/drm/i915/i915_query.c
@@ -6,6 +6,8 @@
 
 #include <linux/nospec.h>
 
+#include "gt/intel_engine_pm.h"
+#include "gt/intel_engine_user.h"
 #include "i915_drv.h"
 #include "i915_perf.h"
 #include "i915_query.h"
@@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
 	return total_length;
 }
 
+typedef u64 (*__ktime_func_t)(void);
+static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
+{
+	/*
+	 * Use logic same as the perf subsystem to allow user to select the
+	 * reference clock id to be used for timestamps.
+	 */
+	switch (clk_id) {
+	case CLOCK_MONOTONIC:
+		return &ktime_get_ns;
+	case CLOCK_MONOTONIC_RAW:
+		return &ktime_get_raw_ns;
+	case CLOCK_REALTIME:
+		return &ktime_get_real_ns;
+	case CLOCK_BOOTTIME:
+		return &ktime_get_boottime_ns;
+	case CLOCK_TAI:
+		return &ktime_get_clocktai_ns;
+	default:
+		return NULL;
+	}
+}
+
+static inline int
+__read_timestamps(struct intel_uncore *uncore,
+		  i915_reg_t lower_reg,
+		  i915_reg_t upper_reg,
+		  u64 *cs_ts,
+		  u64 *cpu_ts,
+		  __ktime_func_t cpu_clock)
+{
+	u32 upper, lower, old_upper, loop = 0;
+
+	upper = intel_uncore_read_fw(uncore, upper_reg);
+	do {
+		cpu_ts[1] = local_clock();
+		cpu_ts[0] = cpu_clock();
+		lower = intel_uncore_read_fw(uncore, lower_reg);
+		cpu_ts[1] = local_clock() - cpu_ts[1];
+		old_upper = upper;
+		upper = intel_uncore_read_fw(uncore, upper_reg);
+	} while (upper != old_upper && loop++ < 2);
+
+	*cs_ts = (u64)upper << 32 | lower;
+
+	return 0;
+}
+
+static int
+__query_cs_cycles(struct intel_engine_cs *engine,
+		  u64 *cs_ts, u64 *cpu_ts,
+		  __ktime_func_t cpu_clock)
+{
+	struct intel_uncore *uncore = engine->uncore;
+	enum forcewake_domains fw_domains;
+	u32 base = engine->mmio_base;
+	intel_wakeref_t wakeref;
+	int ret;
+
+	fw_domains = intel_uncore_forcewake_for_reg(uncore,
+						    RING_TIMESTAMP(base),
+						    FW_REG_READ);
+
+	with_intel_runtime_pm(uncore->rpm, wakeref) {
+		spin_lock_irq(&uncore->lock);
+		intel_uncore_forcewake_get__locked(uncore, fw_domains);
+
+		ret = __read_timestamps(uncore,
+					RING_TIMESTAMP(base),
+					RING_TIMESTAMP_UDW(base),
+					cs_ts,
+					cpu_ts,
+					cpu_clock);
+
+		intel_uncore_forcewake_put__locked(uncore, fw_domains);
+		spin_unlock_irq(&uncore->lock);
+	}
+
+	return ret;
+}
+
+static int
+query_cs_cycles(struct drm_i915_private *i915,
+		struct drm_i915_query_item *query_item)
+{
+	struct drm_i915_query_cs_cycles __user *query_ptr;
+	struct drm_i915_query_cs_cycles query;
+	struct intel_engine_cs *engine;
+	__ktime_func_t cpu_clock;
+	int ret;
+
+	if (GRAPHICS_VER(i915) < 6)
+		return -ENODEV;
+
+	query_ptr = u64_to_user_ptr(query_item->data_ptr);
+	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
+	if (ret != 0)
+		return ret;
+
+	if (query.flags)
+		return -EINVAL;
+
+	if (query.rsvd)
+		return -EINVAL;
+
+	cpu_clock = __clock_id_to_func(query.clockid);
+	if (!cpu_clock)
+		return -EINVAL;
+
+	engine = intel_engine_lookup_user(i915,
+					  query.engine.engine_class,
+					  query.engine.engine_instance);
+	if (!engine)
+		return -EINVAL;
+
+	if (GRAPHICS_VER(i915) == 6 &&
+	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
+		return -ENODEV;
+
+	query.cs_frequency = engine->gt->clock_frequency;
+	ret = __query_cs_cycles(engine,
+				&query.cs_cycles,
+				query.cpu_timestamp,
+				cpu_clock);
+	if (ret)
+		return ret;
+
+	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
+		return -EFAULT;
+
+	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
+		return -EFAULT;
+
+	return sizeof(query);
+}
+
 static int
 query_engine_info(struct drm_i915_private *i915,
 		  struct drm_i915_query_item *query_item)
@@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
 	query_topology_info,
 	query_engine_info,
 	query_perf_config,
+	query_cs_cycles,
 };
 
 int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
index 6a34243a7646..08b00f1709b5 100644
--- a/include/uapi/drm/i915_drm.h
+++ b/include/uapi/drm/i915_drm.h
@@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
 #define DRM_I915_QUERY_TOPOLOGY_INFO    1
 #define DRM_I915_QUERY_ENGINE_INFO	2
 #define DRM_I915_QUERY_PERF_CONFIG      3
+	/**
+	 * Query Command Streamer timestamp register.
+	 */
+#define DRM_I915_QUERY_CS_CYCLES	4
 /* Must be kept compact -- no holes and well documented */
 
 	/**
@@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
 	__u64 rsvd1[4];
 };
 
+/**
+ * struct drm_i915_query_cs_cycles
+ *
+ * The query returns the command streamer cycles and the frequency that can be
+ * used to calculate the command streamer timestamp. In addition the query
+ * returns a set of cpu timestamps that indicate when the command streamer cycle
+ * count was captured.
+ */
+struct drm_i915_query_cs_cycles {
+	/** Engine for which command streamer cycles is queried. */
+	struct i915_engine_class_instance engine;
+
+	/** Must be zero. */
+	__u32 flags;
+
+	/**
+	 * Command streamer cycles as read from the command streamer
+	 * register at 0x358 offset.
+	 */
+	__u64 cs_cycles;
+
+	/** Frequency of the cs cycles in Hz. */
+	__u64 cs_frequency;
+
+	/**
+	 * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
+	 * cs_cycles register using the reference clockid set by the user.
+	 * cpu_timestamp[1] is the time taken in ns to read the lower dword of
+	 * the cs_cycles register.
+	 */
+	__u64 cpu_timestamp[2];
+
+	/**
+	 * Reference clock id for CPU timestamp. For definition, see
+	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
+	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
+	 * CLOCK_TAI.
+	 */
+	__s32 clockid;
+
+	/** Must be zero. */
+	__u32 rsvd;
+};
+
 /**
  * struct drm_i915_query_engine_info
  *
-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jani Nikula]

On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
> Perf measurements rely on CPU and engine timestamps to correlate
> events of interest across these time domains. Current mechanisms get
> these timestamps separately and the calculated delta between these
> timestamps lack enough accuracy.
>
> To improve the accuracy of these time measurements to within a few us,
> add a query that returns the engine and cpu timestamps captured as
> close to each other as possible.

Cc: dri-devel, Jason and Daniel for review.

>
> v2: (Tvrtko)
> - document clock reference used
> - return cpu timestamp always
> - capture cpu time just before lower dword of cs timestamp
>
> v3: (Chris)
> - use uncore-rpm
> - use __query_cs_timestamp helper
>
> v4: (Lionel)
> - Kernel perf subsytem allows users to specify the clock id to be used
>   in perf_event_open. This clock id is used by the perf subsystem to
>   return the appropriate cpu timestamp in perf events. Similarly, let
>   the user pass the clockid to this query so that cpu timestamp
>   corresponds to the clock id requested.
>
> v5: (Tvrtko)
> - Use normal ktime accessors instead of fast versions
> - Add more uApi documentation
>
> v6: (Lionel)
> - Move switch out of spinlock
>
> v7: (Chris)
> - cs_timestamp is a misnomer, use cs_cycles instead
> - return the cs cycle frequency as well in the query
>
> v8:
> - Add platform and engine specific checks
>
> v9: (Lionel)
> - Return 2 cpu timestamps in the query - captured before and after the
>   register read
>
> v10: (Chris)
> - Use local_clock() to measure time taken to read lower dword of
>   register and return it to user.
>
> v11: (Jani)
> - IS_GEN deprecated. User GRAPHICS_VER instead.
>
> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> ---
>  drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>  include/uapi/drm/i915_drm.h       |  48 ++++++++++
>  2 files changed, 193 insertions(+)
>
> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> index fed337ad7b68..2594b93901ac 100644
> --- a/drivers/gpu/drm/i915/i915_query.c
> +++ b/drivers/gpu/drm/i915/i915_query.c
> @@ -6,6 +6,8 @@
>  
>  #include <linux/nospec.h>
>  
> +#include "gt/intel_engine_pm.h"
> +#include "gt/intel_engine_user.h"
>  #include "i915_drv.h"
>  #include "i915_perf.h"
>  #include "i915_query.h"
> @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>  	return total_length;
>  }
>  
> +typedef u64 (*__ktime_func_t)(void);
> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> +{
> +	/*
> +	 * Use logic same as the perf subsystem to allow user to select the
> +	 * reference clock id to be used for timestamps.
> +	 */
> +	switch (clk_id) {
> +	case CLOCK_MONOTONIC:
> +		return &ktime_get_ns;
> +	case CLOCK_MONOTONIC_RAW:
> +		return &ktime_get_raw_ns;
> +	case CLOCK_REALTIME:
> +		return &ktime_get_real_ns;
> +	case CLOCK_BOOTTIME:
> +		return &ktime_get_boottime_ns;
> +	case CLOCK_TAI:
> +		return &ktime_get_clocktai_ns;
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static inline int
> +__read_timestamps(struct intel_uncore *uncore,
> +		  i915_reg_t lower_reg,
> +		  i915_reg_t upper_reg,
> +		  u64 *cs_ts,
> +		  u64 *cpu_ts,
> +		  __ktime_func_t cpu_clock)
> +{
> +	u32 upper, lower, old_upper, loop = 0;
> +
> +	upper = intel_uncore_read_fw(uncore, upper_reg);
> +	do {
> +		cpu_ts[1] = local_clock();
> +		cpu_ts[0] = cpu_clock();
> +		lower = intel_uncore_read_fw(uncore, lower_reg);
> +		cpu_ts[1] = local_clock() - cpu_ts[1];
> +		old_upper = upper;
> +		upper = intel_uncore_read_fw(uncore, upper_reg);
> +	} while (upper != old_upper && loop++ < 2);
> +
> +	*cs_ts = (u64)upper << 32 | lower;
> +
> +	return 0;
> +}
> +
> +static int
> +__query_cs_cycles(struct intel_engine_cs *engine,
> +		  u64 *cs_ts, u64 *cpu_ts,
> +		  __ktime_func_t cpu_clock)
> +{
> +	struct intel_uncore *uncore = engine->uncore;
> +	enum forcewake_domains fw_domains;
> +	u32 base = engine->mmio_base;
> +	intel_wakeref_t wakeref;
> +	int ret;
> +
> +	fw_domains = intel_uncore_forcewake_for_reg(uncore,
> +						    RING_TIMESTAMP(base),
> +						    FW_REG_READ);
> +
> +	with_intel_runtime_pm(uncore->rpm, wakeref) {
> +		spin_lock_irq(&uncore->lock);
> +		intel_uncore_forcewake_get__locked(uncore, fw_domains);
> +
> +		ret = __read_timestamps(uncore,
> +					RING_TIMESTAMP(base),
> +					RING_TIMESTAMP_UDW(base),
> +					cs_ts,
> +					cpu_ts,
> +					cpu_clock);
> +
> +		intel_uncore_forcewake_put__locked(uncore, fw_domains);
> +		spin_unlock_irq(&uncore->lock);
> +	}
> +
> +	return ret;
> +}
> +
> +static int
> +query_cs_cycles(struct drm_i915_private *i915,
> +		struct drm_i915_query_item *query_item)
> +{
> +	struct drm_i915_query_cs_cycles __user *query_ptr;
> +	struct drm_i915_query_cs_cycles query;
> +	struct intel_engine_cs *engine;
> +	__ktime_func_t cpu_clock;
> +	int ret;
> +
> +	if (GRAPHICS_VER(i915) < 6)
> +		return -ENODEV;
> +
> +	query_ptr = u64_to_user_ptr(query_item->data_ptr);
> +	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> +	if (ret != 0)
> +		return ret;
> +
> +	if (query.flags)
> +		return -EINVAL;
> +
> +	if (query.rsvd)
> +		return -EINVAL;
> +
> +	cpu_clock = __clock_id_to_func(query.clockid);
> +	if (!cpu_clock)
> +		return -EINVAL;
> +
> +	engine = intel_engine_lookup_user(i915,
> +					  query.engine.engine_class,
> +					  query.engine.engine_instance);
> +	if (!engine)
> +		return -EINVAL;
> +
> +	if (GRAPHICS_VER(i915) == 6 &&
> +	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> +		return -ENODEV;
> +
> +	query.cs_frequency = engine->gt->clock_frequency;
> +	ret = __query_cs_cycles(engine,
> +				&query.cs_cycles,
> +				query.cpu_timestamp,
> +				cpu_clock);
> +	if (ret)
> +		return ret;
> +
> +	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> +		return -EFAULT;
> +
> +	if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
> +		return -EFAULT;
> +
> +	if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
> +		return -EFAULT;
> +
> +	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> +		return -EFAULT;
> +
> +	return sizeof(query);
> +}
> +
>  static int
>  query_engine_info(struct drm_i915_private *i915,
>  		  struct drm_i915_query_item *query_item)
> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>  	query_topology_info,
>  	query_engine_info,
>  	query_perf_config,
> +	query_cs_cycles,
>  };
>  
>  int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> index 6a34243a7646..08b00f1709b5 100644
> --- a/include/uapi/drm/i915_drm.h
> +++ b/include/uapi/drm/i915_drm.h
> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>  #define DRM_I915_QUERY_ENGINE_INFO	2
>  #define DRM_I915_QUERY_PERF_CONFIG      3
> +	/**
> +	 * Query Command Streamer timestamp register.
> +	 */
> +#define DRM_I915_QUERY_CS_CYCLES	4
>  /* Must be kept compact -- no holes and well documented */
>  
>  	/**
> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>  	__u64 rsvd1[4];
>  };
>  
> +/**
> + * struct drm_i915_query_cs_cycles
> + *
> + * The query returns the command streamer cycles and the frequency that can be
> + * used to calculate the command streamer timestamp. In addition the query
> + * returns a set of cpu timestamps that indicate when the command streamer cycle
> + * count was captured.
> + */
> +struct drm_i915_query_cs_cycles {
> +	/** Engine for which command streamer cycles is queried. */
> +	struct i915_engine_class_instance engine;
> +
> +	/** Must be zero. */
> +	__u32 flags;
> +
> +	/**
> +	 * Command streamer cycles as read from the command streamer
> +	 * register at 0x358 offset.
> +	 */
> +	__u64 cs_cycles;
> +
> +	/** Frequency of the cs cycles in Hz. */
> +	__u64 cs_frequency;
> +
> +	/**
> +	 * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
> +	 * cs_cycles register using the reference clockid set by the user.
> +	 * cpu_timestamp[1] is the time taken in ns to read the lower dword of
> +	 * the cs_cycles register.
> +	 */
> +	__u64 cpu_timestamp[2];
> +
> +	/**
> +	 * Reference clock id for CPU timestamp. For definition, see
> +	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> +	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> +	 * CLOCK_TAI.
> +	 */
> +	__s32 clockid;
> +
> +	/** Must be zero. */
> +	__u32 rsvd;
> +};
> +
>  /**
>   * struct drm_i915_query_engine_info
>   *

-- 
Jani Nikula, Intel Open Source Graphics Center
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jason Ekstrand]

On Wed, Apr 28, 2021 at 3:43 AM Jani Nikula <jani.nikula@linux.intel.com> wrote:
>
> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
> > Perf measurements rely on CPU and engine timestamps to correlate
> > events of interest across these time domains. Current mechanisms get
> > these timestamps separately and the calculated delta between these
> > timestamps lack enough accuracy.
> >
> > To improve the accuracy of these time measurements to within a few us,
> > add a query that returns the engine and cpu timestamps captured as
> > close to each other as possible.
>
> Cc: dri-devel, Jason and Daniel for review.

Thanks!

> >
> > v2: (Tvrtko)
> > - document clock reference used
> > - return cpu timestamp always
> > - capture cpu time just before lower dword of cs timestamp
> >
> > v3: (Chris)
> > - use uncore-rpm
> > - use __query_cs_timestamp helper
> >
> > v4: (Lionel)
> > - Kernel perf subsytem allows users to specify the clock id to be used
> >   in perf_event_open. This clock id is used by the perf subsystem to
> >   return the appropriate cpu timestamp in perf events. Similarly, let
> >   the user pass the clockid to this query so that cpu timestamp
> >   corresponds to the clock id requested.
> >
> > v5: (Tvrtko)
> > - Use normal ktime accessors instead of fast versions
> > - Add more uApi documentation
> >
> > v6: (Lionel)
> > - Move switch out of spinlock
> >
> > v7: (Chris)
> > - cs_timestamp is a misnomer, use cs_cycles instead
> > - return the cs cycle frequency as well in the query
> >
> > v8:
> > - Add platform and engine specific checks
> >
> > v9: (Lionel)
> > - Return 2 cpu timestamps in the query - captured before and after the
> >   register read
> >
> > v10: (Chris)
> > - Use local_clock() to measure time taken to read lower dword of
> >   register and return it to user.
> >
> > v11: (Jani)
> > - IS_GEN deprecated. User GRAPHICS_VER instead.
> >
> > Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> > ---
> >  drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
> >  include/uapi/drm/i915_drm.h       |  48 ++++++++++
> >  2 files changed, 193 insertions(+)
> >
> > diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> > index fed337ad7b68..2594b93901ac 100644
> > --- a/drivers/gpu/drm/i915/i915_query.c
> > +++ b/drivers/gpu/drm/i915/i915_query.c
> > @@ -6,6 +6,8 @@
> >
> >  #include <linux/nospec.h>
> >
> > +#include "gt/intel_engine_pm.h"
> > +#include "gt/intel_engine_user.h"
> >  #include "i915_drv.h"
> >  #include "i915_perf.h"
> >  #include "i915_query.h"
> > @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
> >       return total_length;
> >  }
> >
> > +typedef u64 (*__ktime_func_t)(void);
> > +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> > +{
> > +     /*
> > +      * Use logic same as the perf subsystem to allow user to select the
> > +      * reference clock id to be used for timestamps.
> > +      */
> > +     switch (clk_id) {
> > +     case CLOCK_MONOTONIC:
> > +             return &ktime_get_ns;
> > +     case CLOCK_MONOTONIC_RAW:
> > +             return &ktime_get_raw_ns;
> > +     case CLOCK_REALTIME:
> > +             return &ktime_get_real_ns;
> > +     case CLOCK_BOOTTIME:
> > +             return &ktime_get_boottime_ns;
> > +     case CLOCK_TAI:
> > +             return &ktime_get_clocktai_ns;
> > +     default:
> > +             return NULL;
> > +     }
> > +}
> > +
> > +static inline int
> > +__read_timestamps(struct intel_uncore *uncore,
> > +               i915_reg_t lower_reg,
> > +               i915_reg_t upper_reg,
> > +               u64 *cs_ts,
> > +               u64 *cpu_ts,
> > +               __ktime_func_t cpu_clock)
> > +{
> > +     u32 upper, lower, old_upper, loop = 0;
> > +
> > +     upper = intel_uncore_read_fw(uncore, upper_reg);
> > +     do {
> > +             cpu_ts[1] = local_clock();
> > +             cpu_ts[0] = cpu_clock();
> > +             lower = intel_uncore_read_fw(uncore, lower_reg);
> > +             cpu_ts[1] = local_clock() - cpu_ts[1];
> > +             old_upper = upper;
> > +             upper = intel_uncore_read_fw(uncore, upper_reg);
> > +     } while (upper != old_upper && loop++ < 2);
> > +
> > +     *cs_ts = (u64)upper << 32 | lower;
> > +
> > +     return 0;
> > +}
> > +
> > +static int
> > +__query_cs_cycles(struct intel_engine_cs *engine,
> > +               u64 *cs_ts, u64 *cpu_ts,
> > +               __ktime_func_t cpu_clock)
> > +{
> > +     struct intel_uncore *uncore = engine->uncore;
> > +     enum forcewake_domains fw_domains;
> > +     u32 base = engine->mmio_base;
> > +     intel_wakeref_t wakeref;
> > +     int ret;
> > +
> > +     fw_domains = intel_uncore_forcewake_for_reg(uncore,
> > +                                                 RING_TIMESTAMP(base),
> > +                                                 FW_REG_READ);
> > +
> > +     with_intel_runtime_pm(uncore->rpm, wakeref) {
> > +             spin_lock_irq(&uncore->lock);
> > +             intel_uncore_forcewake_get__locked(uncore, fw_domains);
> > +
> > +             ret = __read_timestamps(uncore,
> > +                                     RING_TIMESTAMP(base),
> > +                                     RING_TIMESTAMP_UDW(base),
> > +                                     cs_ts,
> > +                                     cpu_ts,
> > +                                     cpu_clock);
> > +
> > +             intel_uncore_forcewake_put__locked(uncore, fw_domains);
> > +             spin_unlock_irq(&uncore->lock);
> > +     }
> > +
> > +     return ret;
> > +}
> > +
> > +static int
> > +query_cs_cycles(struct drm_i915_private *i915,
> > +             struct drm_i915_query_item *query_item)
> > +{
> > +     struct drm_i915_query_cs_cycles __user *query_ptr;
> > +     struct drm_i915_query_cs_cycles query;
> > +     struct intel_engine_cs *engine;
> > +     __ktime_func_t cpu_clock;
> > +     int ret;
> > +
> > +     if (GRAPHICS_VER(i915) < 6)
> > +             return -ENODEV;
> > +
> > +     query_ptr = u64_to_user_ptr(query_item->data_ptr);
> > +     ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> > +     if (ret != 0)
> > +             return ret;
> > +
> > +     if (query.flags)
> > +             return -EINVAL;
> > +
> > +     if (query.rsvd)
> > +             return -EINVAL;
> > +
> > +     cpu_clock = __clock_id_to_func(query.clockid);
> > +     if (!cpu_clock)
> > +             return -EINVAL;
> > +
> > +     engine = intel_engine_lookup_user(i915,
> > +                                       query.engine.engine_class,
> > +                                       query.engine.engine_instance);
> > +     if (!engine)
> > +             return -EINVAL;
> > +
> > +     if (GRAPHICS_VER(i915) == 6 &&
> > +         query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> > +             return -ENODEV;
> > +
> > +     query.cs_frequency = engine->gt->clock_frequency;
> > +     ret = __query_cs_cycles(engine,
> > +                             &query.cs_cycles,
> > +                             query.cpu_timestamp,
> > +                             cpu_clock);
> > +     if (ret)
> > +             return ret;
> > +
> > +     if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> > +             return -EFAULT;
> > +
> > +     if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
> > +             return -EFAULT;
> > +
> > +     if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
> > +             return -EFAULT;
> > +
> > +     if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> > +             return -EFAULT;
> > +
> > +     return sizeof(query);
> > +}
> > +
> >  static int
> >  query_engine_info(struct drm_i915_private *i915,
> >                 struct drm_i915_query_item *query_item)
> > @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
> >       query_topology_info,
> >       query_engine_info,
> >       query_perf_config,
> > +     query_cs_cycles,
> >  };
> >
> >  int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> > diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> > index 6a34243a7646..08b00f1709b5 100644
> > --- a/include/uapi/drm/i915_drm.h
> > +++ b/include/uapi/drm/i915_drm.h
> > @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
> >  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
> >  #define DRM_I915_QUERY_ENGINE_INFO   2
> >  #define DRM_I915_QUERY_PERF_CONFIG      3
> > +     /**
> > +      * Query Command Streamer timestamp register.
> > +      */
> > +#define DRM_I915_QUERY_CS_CYCLES     4
> >  /* Must be kept compact -- no holes and well documented */
> >
> >       /**
> > @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
> >       __u64 rsvd1[4];
> >  };
> >
> > +/**
> > + * struct drm_i915_query_cs_cycles
> > + *
> > + * The query returns the command streamer cycles and the frequency that can be
> > + * used to calculate the command streamer timestamp. In addition the query
> > + * returns a set of cpu timestamps that indicate when the command streamer cycle
> > + * count was captured.
> > + */
> > +struct drm_i915_query_cs_cycles {
> > +     /** Engine for which command streamer cycles is queried. */
> > +     struct i915_engine_class_instance engine;

Why is this per-engine?  Do we actually expect it to change between
engines?  If so, we may have a problem because Vulkan expects a
unified timestamp domain for all command streamer timestamp queries.

--Jason


> > +     /** Must be zero. */
> > +     __u32 flags;
> > +
> > +     /**
> > +      * Command streamer cycles as read from the command streamer
> > +      * register at 0x358 offset.
> > +      */
> > +     __u64 cs_cycles;
> > +
> > +     /** Frequency of the cs cycles in Hz. */
> > +     __u64 cs_frequency;
> > +
> > +     /**
> > +      * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
> > +      * cs_cycles register using the reference clockid set by the user.
> > +      * cpu_timestamp[1] is the time taken in ns to read the lower dword of
> > +      * the cs_cycles register.
> > +      */
> > +     __u64 cpu_timestamp[2];
> > +
> > +     /**
> > +      * Reference clock id for CPU timestamp. For definition, see
> > +      * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> > +      * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> > +      * CLOCK_TAI.
> > +      */
> > +     __s32 clockid;
> > +
> > +     /** Must be zero. */
> > +     __u32 rsvd;
> > +};
> > +
> >  /**
> >   * struct drm_i915_query_engine_info
> >   *
>
> --
> Jani Nikula, Intel Open Source Graphics Center
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Lionel Landwerlin]

[-- Attachment #1.1: Type: text/plain, Size: 11184 bytes --]

On 28/04/2021 22:24, Jason Ekstrand wrote:
> On Wed, Apr 28, 2021 at 3:43 AM Jani Nikula <jani.nikula@linux.intel.com> wrote:
>> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
>>> Perf measurements rely on CPU and engine timestamps to correlate
>>> events of interest across these time domains. Current mechanisms get
>>> these timestamps separately and the calculated delta between these
>>> timestamps lack enough accuracy.
>>>
>>> To improve the accuracy of these time measurements to within a few us,
>>> add a query that returns the engine and cpu timestamps captured as
>>> close to each other as possible.
>> Cc: dri-devel, Jason and Daniel for review.
> Thanks!
>
>>> v2: (Tvrtko)
>>> - document clock reference used
>>> - return cpu timestamp always
>>> - capture cpu time just before lower dword of cs timestamp
>>>
>>> v3: (Chris)
>>> - use uncore-rpm
>>> - use __query_cs_timestamp helper
>>>
>>> v4: (Lionel)
>>> - Kernel perf subsytem allows users to specify the clock id to be used
>>>    in perf_event_open. This clock id is used by the perf subsystem to
>>>    return the appropriate cpu timestamp in perf events. Similarly, let
>>>    the user pass the clockid to this query so that cpu timestamp
>>>    corresponds to the clock id requested.
>>>
>>> v5: (Tvrtko)
>>> - Use normal ktime accessors instead of fast versions
>>> - Add more uApi documentation
>>>
>>> v6: (Lionel)
>>> - Move switch out of spinlock
>>>
>>> v7: (Chris)
>>> - cs_timestamp is a misnomer, use cs_cycles instead
>>> - return the cs cycle frequency as well in the query
>>>
>>> v8:
>>> - Add platform and engine specific checks
>>>
>>> v9: (Lionel)
>>> - Return 2 cpu timestamps in the query - captured before and after the
>>>    register read
>>>
>>> v10: (Chris)
>>> - Use local_clock() to measure time taken to read lower dword of
>>>    register and return it to user.
>>>
>>> v11: (Jani)
>>> - IS_GEN deprecated. User GRAPHICS_VER instead.
>>>
>>> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
>>> ---
>>>   drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>>>   include/uapi/drm/i915_drm.h       |  48 ++++++++++
>>>   2 files changed, 193 insertions(+)
>>>
>>> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
>>> index fed337ad7b68..2594b93901ac 100644
>>> --- a/drivers/gpu/drm/i915/i915_query.c
>>> +++ b/drivers/gpu/drm/i915/i915_query.c
>>> @@ -6,6 +6,8 @@
>>>
>>>   #include <linux/nospec.h>
>>>
>>> +#include "gt/intel_engine_pm.h"
>>> +#include "gt/intel_engine_user.h"
>>>   #include "i915_drv.h"
>>>   #include "i915_perf.h"
>>>   #include "i915_query.h"
>>> @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>>>        return total_length;
>>>   }
>>>
>>> +typedef u64 (*__ktime_func_t)(void);
>>> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
>>> +{
>>> +     /*
>>> +      * Use logic same as the perf subsystem to allow user to select the
>>> +      * reference clock id to be used for timestamps.
>>> +      */
>>> +     switch (clk_id) {
>>> +     case CLOCK_MONOTONIC:
>>> +             return &ktime_get_ns;
>>> +     case CLOCK_MONOTONIC_RAW:
>>> +             return &ktime_get_raw_ns;
>>> +     case CLOCK_REALTIME:
>>> +             return &ktime_get_real_ns;
>>> +     case CLOCK_BOOTTIME:
>>> +             return &ktime_get_boottime_ns;
>>> +     case CLOCK_TAI:
>>> +             return &ktime_get_clocktai_ns;
>>> +     default:
>>> +             return NULL;
>>> +     }
>>> +}
>>> +
>>> +static inline int
>>> +__read_timestamps(struct intel_uncore *uncore,
>>> +               i915_reg_t lower_reg,
>>> +               i915_reg_t upper_reg,
>>> +               u64 *cs_ts,
>>> +               u64 *cpu_ts,
>>> +               __ktime_func_t cpu_clock)
>>> +{
>>> +     u32 upper, lower, old_upper, loop = 0;
>>> +
>>> +     upper = intel_uncore_read_fw(uncore, upper_reg);
>>> +     do {
>>> +             cpu_ts[1] = local_clock();
>>> +             cpu_ts[0] = cpu_clock();
>>> +             lower = intel_uncore_read_fw(uncore, lower_reg);
>>> +             cpu_ts[1] = local_clock() - cpu_ts[1];
>>> +             old_upper = upper;
>>> +             upper = intel_uncore_read_fw(uncore, upper_reg);
>>> +     } while (upper != old_upper && loop++ < 2);
>>> +
>>> +     *cs_ts = (u64)upper << 32 | lower;
>>> +
>>> +     return 0;
>>> +}
>>> +
>>> +static int
>>> +__query_cs_cycles(struct intel_engine_cs *engine,
>>> +               u64 *cs_ts, u64 *cpu_ts,
>>> +               __ktime_func_t cpu_clock)
>>> +{
>>> +     struct intel_uncore *uncore = engine->uncore;
>>> +     enum forcewake_domains fw_domains;
>>> +     u32 base = engine->mmio_base;
>>> +     intel_wakeref_t wakeref;
>>> +     int ret;
>>> +
>>> +     fw_domains = intel_uncore_forcewake_for_reg(uncore,
>>> +                                                 RING_TIMESTAMP(base),
>>> +                                                 FW_REG_READ);
>>> +
>>> +     with_intel_runtime_pm(uncore->rpm, wakeref) {
>>> +             spin_lock_irq(&uncore->lock);
>>> +             intel_uncore_forcewake_get__locked(uncore, fw_domains);
>>> +
>>> +             ret = __read_timestamps(uncore,
>>> +                                     RING_TIMESTAMP(base),
>>> +                                     RING_TIMESTAMP_UDW(base),
>>> +                                     cs_ts,
>>> +                                     cpu_ts,
>>> +                                     cpu_clock);
>>> +
>>> +             intel_uncore_forcewake_put__locked(uncore, fw_domains);
>>> +             spin_unlock_irq(&uncore->lock);
>>> +     }
>>> +
>>> +     return ret;
>>> +}
>>> +
>>> +static int
>>> +query_cs_cycles(struct drm_i915_private *i915,
>>> +             struct drm_i915_query_item *query_item)
>>> +{
>>> +     struct drm_i915_query_cs_cycles __user *query_ptr;
>>> +     struct drm_i915_query_cs_cycles query;
>>> +     struct intel_engine_cs *engine;
>>> +     __ktime_func_t cpu_clock;
>>> +     int ret;
>>> +
>>> +     if (GRAPHICS_VER(i915) < 6)
>>> +             return -ENODEV;
>>> +
>>> +     query_ptr = u64_to_user_ptr(query_item->data_ptr);
>>> +     ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
>>> +     if (ret != 0)
>>> +             return ret;
>>> +
>>> +     if (query.flags)
>>> +             return -EINVAL;
>>> +
>>> +     if (query.rsvd)
>>> +             return -EINVAL;
>>> +
>>> +     cpu_clock = __clock_id_to_func(query.clockid);
>>> +     if (!cpu_clock)
>>> +             return -EINVAL;
>>> +
>>> +     engine = intel_engine_lookup_user(i915,
>>> +                                       query.engine.engine_class,
>>> +                                       query.engine.engine_instance);
>>> +     if (!engine)
>>> +             return -EINVAL;
>>> +
>>> +     if (GRAPHICS_VER(i915) == 6 &&
>>> +         query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>>> +             return -ENODEV;
>>> +
>>> +     query.cs_frequency = engine->gt->clock_frequency;
>>> +     ret = __query_cs_cycles(engine,
>>> +                             &query.cs_cycles,
>>> +                             query.cpu_timestamp,
>>> +                             cpu_clock);
>>> +     if (ret)
>>> +             return ret;
>>> +
>>> +     if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
>>> +             return -EFAULT;
>>> +
>>> +     if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
>>> +             return -EFAULT;
>>> +
>>> +     if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
>>> +             return -EFAULT;
>>> +
>>> +     if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
>>> +             return -EFAULT;
>>> +
>>> +     return sizeof(query);
>>> +}
>>> +
>>>   static int
>>>   query_engine_info(struct drm_i915_private *i915,
>>>                  struct drm_i915_query_item *query_item)
>>> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>>>        query_topology_info,
>>>        query_engine_info,
>>>        query_perf_config,
>>> +     query_cs_cycles,
>>>   };
>>>
>>>   int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
>>> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
>>> index 6a34243a7646..08b00f1709b5 100644
>>> --- a/include/uapi/drm/i915_drm.h
>>> +++ b/include/uapi/drm/i915_drm.h
>>> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>>>   #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>>>   #define DRM_I915_QUERY_ENGINE_INFO   2
>>>   #define DRM_I915_QUERY_PERF_CONFIG      3
>>> +     /**
>>> +      * Query Command Streamer timestamp register.
>>> +      */
>>> +#define DRM_I915_QUERY_CS_CYCLES     4
>>>   /* Must be kept compact -- no holes and well documented */
>>>
>>>        /**
>>> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>>>        __u64 rsvd1[4];
>>>   };
>>>
>>> +/**
>>> + * struct drm_i915_query_cs_cycles
>>> + *
>>> + * The query returns the command streamer cycles and the frequency that can be
>>> + * used to calculate the command streamer timestamp. In addition the query
>>> + * returns a set of cpu timestamps that indicate when the command streamer cycle
>>> + * count was captured.
>>> + */
>>> +struct drm_i915_query_cs_cycles {
>>> +     /** Engine for which command streamer cycles is queried. */
>>> +     struct i915_engine_class_instance engine;
> Why is this per-engine?  Do we actually expect it to change between
> engines?


Each engine has its own timestamp register.


>    If so, we may have a problem because Vulkan expects a
> unified timestamp domain for all command streamer timestamp queries.


I don't think it does : "

Timestamps*may*only be meaningfully compared if they are written by 
commands submitted to the same queue.

" [1]


[1] : 
https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html


-Lionel


>
> --Jason
>
>
>>> +     /** Must be zero. */
>>> +     __u32 flags;
>>> +
>>> +     /**
>>> +      * Command streamer cycles as read from the command streamer
>>> +      * register at 0x358 offset.
>>> +      */
>>> +     __u64 cs_cycles;
>>> +
>>> +     /** Frequency of the cs cycles in Hz. */
>>> +     __u64 cs_frequency;
>>> +
>>> +     /**
>>> +      * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
>>> +      * cs_cycles register using the reference clockid set by the user.
>>> +      * cpu_timestamp[1] is the time taken in ns to read the lower dword of
>>> +      * the cs_cycles register.
>>> +      */
>>> +     __u64 cpu_timestamp[2];
>>> +
>>> +     /**
>>> +      * Reference clock id for CPU timestamp. For definition, see
>>> +      * clock_gettime(2) and perf_event_open(2). Supported clock ids are
>>> +      * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
>>> +      * CLOCK_TAI.
>>> +      */
>>> +     __s32 clockid;
>>> +
>>> +     /** Must be zero. */
>>> +     __u32 rsvd;
>>> +};
>>> +
>>>   /**
>>>    * struct drm_i915_query_engine_info
>>>    *
>> --
>> Jani Nikula, Intel Open Source Graphics Center



[-- Attachment #1.2: Type: text/html, Size: 13283 bytes --]

[-- Attachment #2: Type: text/plain, Size: 160 bytes --]

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jason Ekstrand]

On Wed, Apr 28, 2021 at 2:50 PM Lionel Landwerlin
<lionel.g.landwerlin@intel.com> wrote:
>
> On 28/04/2021 22:24, Jason Ekstrand wrote:
>
> On Wed, Apr 28, 2021 at 3:43 AM Jani Nikula <jani.nikula@linux.intel.com> wrote:
>
> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
>
> Perf measurements rely on CPU and engine timestamps to correlate
> events of interest across these time domains. Current mechanisms get
> these timestamps separately and the calculated delta between these
> timestamps lack enough accuracy.
>
> To improve the accuracy of these time measurements to within a few us,
> add a query that returns the engine and cpu timestamps captured as
> close to each other as possible.
>
> Cc: dri-devel, Jason and Daniel for review.
>
> Thanks!
>
> v2: (Tvrtko)
> - document clock reference used
> - return cpu timestamp always
> - capture cpu time just before lower dword of cs timestamp
>
> v3: (Chris)
> - use uncore-rpm
> - use __query_cs_timestamp helper
>
> v4: (Lionel)
> - Kernel perf subsytem allows users to specify the clock id to be used
>   in perf_event_open. This clock id is used by the perf subsystem to
>   return the appropriate cpu timestamp in perf events. Similarly, let
>   the user pass the clockid to this query so that cpu timestamp
>   corresponds to the clock id requested.
>
> v5: (Tvrtko)
> - Use normal ktime accessors instead of fast versions
> - Add more uApi documentation
>
> v6: (Lionel)
> - Move switch out of spinlock
>
> v7: (Chris)
> - cs_timestamp is a misnomer, use cs_cycles instead
> - return the cs cycle frequency as well in the query
>
> v8:
> - Add platform and engine specific checks
>
> v9: (Lionel)
> - Return 2 cpu timestamps in the query - captured before and after the
>   register read
>
> v10: (Chris)
> - Use local_clock() to measure time taken to read lower dword of
>   register and return it to user.
>
> v11: (Jani)
> - IS_GEN deprecated. User GRAPHICS_VER instead.
>
> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> ---
>  drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>  include/uapi/drm/i915_drm.h       |  48 ++++++++++
>  2 files changed, 193 insertions(+)
>
> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> index fed337ad7b68..2594b93901ac 100644
> --- a/drivers/gpu/drm/i915/i915_query.c
> +++ b/drivers/gpu/drm/i915/i915_query.c
> @@ -6,6 +6,8 @@
>
>  #include <linux/nospec.h>
>
> +#include "gt/intel_engine_pm.h"
> +#include "gt/intel_engine_user.h"
>  #include "i915_drv.h"
>  #include "i915_perf.h"
>  #include "i915_query.h"
> @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>       return total_length;
>  }
>
> +typedef u64 (*__ktime_func_t)(void);
> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> +{
> +     /*
> +      * Use logic same as the perf subsystem to allow user to select the
> +      * reference clock id to be used for timestamps.
> +      */
> +     switch (clk_id) {
> +     case CLOCK_MONOTONIC:
> +             return &ktime_get_ns;
> +     case CLOCK_MONOTONIC_RAW:
> +             return &ktime_get_raw_ns;
> +     case CLOCK_REALTIME:
> +             return &ktime_get_real_ns;
> +     case CLOCK_BOOTTIME:
> +             return &ktime_get_boottime_ns;
> +     case CLOCK_TAI:
> +             return &ktime_get_clocktai_ns;
> +     default:
> +             return NULL;
> +     }
> +}
> +
> +static inline int
> +__read_timestamps(struct intel_uncore *uncore,
> +               i915_reg_t lower_reg,
> +               i915_reg_t upper_reg,
> +               u64 *cs_ts,
> +               u64 *cpu_ts,
> +               __ktime_func_t cpu_clock)
> +{
> +     u32 upper, lower, old_upper, loop = 0;
> +
> +     upper = intel_uncore_read_fw(uncore, upper_reg);
> +     do {
> +             cpu_ts[1] = local_clock();
> +             cpu_ts[0] = cpu_clock();
> +             lower = intel_uncore_read_fw(uncore, lower_reg);
> +             cpu_ts[1] = local_clock() - cpu_ts[1];
> +             old_upper = upper;
> +             upper = intel_uncore_read_fw(uncore, upper_reg);
> +     } while (upper != old_upper && loop++ < 2);
> +
> +     *cs_ts = (u64)upper << 32 | lower;
> +
> +     return 0;
> +}
> +
> +static int
> +__query_cs_cycles(struct intel_engine_cs *engine,
> +               u64 *cs_ts, u64 *cpu_ts,
> +               __ktime_func_t cpu_clock)
> +{
> +     struct intel_uncore *uncore = engine->uncore;
> +     enum forcewake_domains fw_domains;
> +     u32 base = engine->mmio_base;
> +     intel_wakeref_t wakeref;
> +     int ret;
> +
> +     fw_domains = intel_uncore_forcewake_for_reg(uncore,
> +                                                 RING_TIMESTAMP(base),
> +                                                 FW_REG_READ);
> +
> +     with_intel_runtime_pm(uncore->rpm, wakeref) {
> +             spin_lock_irq(&uncore->lock);
> +             intel_uncore_forcewake_get__locked(uncore, fw_domains);
> +
> +             ret = __read_timestamps(uncore,
> +                                     RING_TIMESTAMP(base),
> +                                     RING_TIMESTAMP_UDW(base),
> +                                     cs_ts,
> +                                     cpu_ts,
> +                                     cpu_clock);
> +
> +             intel_uncore_forcewake_put__locked(uncore, fw_domains);
> +             spin_unlock_irq(&uncore->lock);
> +     }
> +
> +     return ret;
> +}
> +
> +static int
> +query_cs_cycles(struct drm_i915_private *i915,
> +             struct drm_i915_query_item *query_item)
> +{
> +     struct drm_i915_query_cs_cycles __user *query_ptr;
> +     struct drm_i915_query_cs_cycles query;
> +     struct intel_engine_cs *engine;
> +     __ktime_func_t cpu_clock;
> +     int ret;
> +
> +     if (GRAPHICS_VER(i915) < 6)
> +             return -ENODEV;
> +
> +     query_ptr = u64_to_user_ptr(query_item->data_ptr);
> +     ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> +     if (ret != 0)
> +             return ret;
> +
> +     if (query.flags)
> +             return -EINVAL;
> +
> +     if (query.rsvd)
> +             return -EINVAL;
> +
> +     cpu_clock = __clock_id_to_func(query.clockid);
> +     if (!cpu_clock)
> +             return -EINVAL;
> +
> +     engine = intel_engine_lookup_user(i915,
> +                                       query.engine.engine_class,
> +                                       query.engine.engine_instance);
> +     if (!engine)
> +             return -EINVAL;
> +
> +     if (GRAPHICS_VER(i915) == 6 &&
> +         query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> +             return -ENODEV;
> +
> +     query.cs_frequency = engine->gt->clock_frequency;
> +     ret = __query_cs_cycles(engine,
> +                             &query.cs_cycles,
> +                             query.cpu_timestamp,
> +                             cpu_clock);
> +     if (ret)
> +             return ret;
> +
> +     if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> +             return -EFAULT;
> +
> +     if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
> +             return -EFAULT;
> +
> +     if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
> +             return -EFAULT;
> +
> +     if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> +             return -EFAULT;
> +
> +     return sizeof(query);
> +}
> +
>  static int
>  query_engine_info(struct drm_i915_private *i915,
>                 struct drm_i915_query_item *query_item)
> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>       query_topology_info,
>       query_engine_info,
>       query_perf_config,
> +     query_cs_cycles,
>  };
>
>  int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> index 6a34243a7646..08b00f1709b5 100644
> --- a/include/uapi/drm/i915_drm.h
> +++ b/include/uapi/drm/i915_drm.h
> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>  #define DRM_I915_QUERY_ENGINE_INFO   2
>  #define DRM_I915_QUERY_PERF_CONFIG      3
> +     /**
> +      * Query Command Streamer timestamp register.
> +      */
> +#define DRM_I915_QUERY_CS_CYCLES     4
>  /* Must be kept compact -- no holes and well documented */
>
>       /**
> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>       __u64 rsvd1[4];
>  };
>
> +/**
> + * struct drm_i915_query_cs_cycles
> + *
> + * The query returns the command streamer cycles and the frequency that can be
> + * used to calculate the command streamer timestamp. In addition the query
> + * returns a set of cpu timestamps that indicate when the command streamer cycle
> + * count was captured.
> + */
> +struct drm_i915_query_cs_cycles {
> +     /** Engine for which command streamer cycles is queried. */
> +     struct i915_engine_class_instance engine;
>
> Why is this per-engine?  Do we actually expect it to change between
> engines?
>
>
> Each engine has its own timestamp register.
>
>
>   If so, we may have a problem because Vulkan expects a
> unified timestamp domain for all command streamer timestamp queries.
>
>
> I don't think it does : "
>
> Timestamps may only be meaningfully compared if they are written by commands submitted to the same queue.

Yes but vkGetCalibratedTimestampsEXT() doesn't take a queue or even a
queue family.  Also, VkPhysicalDeviceLimits::timestampPeriod gives a
single timestampPeriod for all queues.  It's possible that Vulkan
messed up real bad there but I thought we did a HW survey at the time
and determined that it was ok.

--Jason


> " [1]
>
>
> [1] : https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html
>
>
> -Lionel
>
>
>
> --Jason
>
>
> +     /** Must be zero. */
> +     __u32 flags;
> +
> +     /**
> +      * Command streamer cycles as read from the command streamer
> +      * register at 0x358 offset.
> +      */
> +     __u64 cs_cycles;
> +
> +     /** Frequency of the cs cycles in Hz. */
> +     __u64 cs_frequency;
> +
> +     /**
> +      * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
> +      * cs_cycles register using the reference clockid set by the user.
> +      * cpu_timestamp[1] is the time taken in ns to read the lower dword of
> +      * the cs_cycles register.
> +      */
> +     __u64 cpu_timestamp[2];
> +
> +     /**
> +      * Reference clock id for CPU timestamp. For definition, see
> +      * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> +      * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> +      * CLOCK_TAI.
> +      */
> +     __s32 clockid;
> +
> +     /** Must be zero. */
> +     __u32 rsvd;
> +};
> +
>  /**
>   * struct drm_i915_query_engine_info
>   *
>
> --
> Jani Nikula, Intel Open Source Graphics Center
>
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Lionel Landwerlin]

On 28/04/2021 22:54, Jason Ekstrand wrote:
> On Wed, Apr 28, 2021 at 2:50 PM Lionel Landwerlin
> <lionel.g.landwerlin@intel.com> wrote:
>> On 28/04/2021 22:24, Jason Ekstrand wrote:
>>
>> On Wed, Apr 28, 2021 at 3:43 AM Jani Nikula <jani.nikula@linux.intel.com> wrote:
>>
>> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
>>
>> Perf measurements rely on CPU and engine timestamps to correlate
>> events of interest across these time domains. Current mechanisms get
>> these timestamps separately and the calculated delta between these
>> timestamps lack enough accuracy.
>>
>> To improve the accuracy of these time measurements to within a few us,
>> add a query that returns the engine and cpu timestamps captured as
>> close to each other as possible.
>>
>> Cc: dri-devel, Jason and Daniel for review.
>>
>> Thanks!
>>
>> v2: (Tvrtko)
>> - document clock reference used
>> - return cpu timestamp always
>> - capture cpu time just before lower dword of cs timestamp
>>
>> v3: (Chris)
>> - use uncore-rpm
>> - use __query_cs_timestamp helper
>>
>> v4: (Lionel)
>> - Kernel perf subsytem allows users to specify the clock id to be used
>>    in perf_event_open. This clock id is used by the perf subsystem to
>>    return the appropriate cpu timestamp in perf events. Similarly, let
>>    the user pass the clockid to this query so that cpu timestamp
>>    corresponds to the clock id requested.
>>
>> v5: (Tvrtko)
>> - Use normal ktime accessors instead of fast versions
>> - Add more uApi documentation
>>
>> v6: (Lionel)
>> - Move switch out of spinlock
>>
>> v7: (Chris)
>> - cs_timestamp is a misnomer, use cs_cycles instead
>> - return the cs cycle frequency as well in the query
>>
>> v8:
>> - Add platform and engine specific checks
>>
>> v9: (Lionel)
>> - Return 2 cpu timestamps in the query - captured before and after the
>>    register read
>>
>> v10: (Chris)
>> - Use local_clock() to measure time taken to read lower dword of
>>    register and return it to user.
>>
>> v11: (Jani)
>> - IS_GEN deprecated. User GRAPHICS_VER instead.
>>
>> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
>> ---
>>   drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>>   include/uapi/drm/i915_drm.h       |  48 ++++++++++
>>   2 files changed, 193 insertions(+)
>>
>> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
>> index fed337ad7b68..2594b93901ac 100644
>> --- a/drivers/gpu/drm/i915/i915_query.c
>> +++ b/drivers/gpu/drm/i915/i915_query.c
>> @@ -6,6 +6,8 @@
>>
>>   #include <linux/nospec.h>
>>
>> +#include "gt/intel_engine_pm.h"
>> +#include "gt/intel_engine_user.h"
>>   #include "i915_drv.h"
>>   #include "i915_perf.h"
>>   #include "i915_query.h"
>> @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>>        return total_length;
>>   }
>>
>> +typedef u64 (*__ktime_func_t)(void);
>> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
>> +{
>> +     /*
>> +      * Use logic same as the perf subsystem to allow user to select the
>> +      * reference clock id to be used for timestamps.
>> +      */
>> +     switch (clk_id) {
>> +     case CLOCK_MONOTONIC:
>> +             return &ktime_get_ns;
>> +     case CLOCK_MONOTONIC_RAW:
>> +             return &ktime_get_raw_ns;
>> +     case CLOCK_REALTIME:
>> +             return &ktime_get_real_ns;
>> +     case CLOCK_BOOTTIME:
>> +             return &ktime_get_boottime_ns;
>> +     case CLOCK_TAI:
>> +             return &ktime_get_clocktai_ns;
>> +     default:
>> +             return NULL;
>> +     }
>> +}
>> +
>> +static inline int
>> +__read_timestamps(struct intel_uncore *uncore,
>> +               i915_reg_t lower_reg,
>> +               i915_reg_t upper_reg,
>> +               u64 *cs_ts,
>> +               u64 *cpu_ts,
>> +               __ktime_func_t cpu_clock)
>> +{
>> +     u32 upper, lower, old_upper, loop = 0;
>> +
>> +     upper = intel_uncore_read_fw(uncore, upper_reg);
>> +     do {
>> +             cpu_ts[1] = local_clock();
>> +             cpu_ts[0] = cpu_clock();
>> +             lower = intel_uncore_read_fw(uncore, lower_reg);
>> +             cpu_ts[1] = local_clock() - cpu_ts[1];
>> +             old_upper = upper;
>> +             upper = intel_uncore_read_fw(uncore, upper_reg);
>> +     } while (upper != old_upper && loop++ < 2);
>> +
>> +     *cs_ts = (u64)upper << 32 | lower;
>> +
>> +     return 0;
>> +}
>> +
>> +static int
>> +__query_cs_cycles(struct intel_engine_cs *engine,
>> +               u64 *cs_ts, u64 *cpu_ts,
>> +               __ktime_func_t cpu_clock)
>> +{
>> +     struct intel_uncore *uncore = engine->uncore;
>> +     enum forcewake_domains fw_domains;
>> +     u32 base = engine->mmio_base;
>> +     intel_wakeref_t wakeref;
>> +     int ret;
>> +
>> +     fw_domains = intel_uncore_forcewake_for_reg(uncore,
>> +                                                 RING_TIMESTAMP(base),
>> +                                                 FW_REG_READ);
>> +
>> +     with_intel_runtime_pm(uncore->rpm, wakeref) {
>> +             spin_lock_irq(&uncore->lock);
>> +             intel_uncore_forcewake_get__locked(uncore, fw_domains);
>> +
>> +             ret = __read_timestamps(uncore,
>> +                                     RING_TIMESTAMP(base),
>> +                                     RING_TIMESTAMP_UDW(base),
>> +                                     cs_ts,
>> +                                     cpu_ts,
>> +                                     cpu_clock);
>> +
>> +             intel_uncore_forcewake_put__locked(uncore, fw_domains);
>> +             spin_unlock_irq(&uncore->lock);
>> +     }
>> +
>> +     return ret;
>> +}
>> +
>> +static int
>> +query_cs_cycles(struct drm_i915_private *i915,
>> +             struct drm_i915_query_item *query_item)
>> +{
>> +     struct drm_i915_query_cs_cycles __user *query_ptr;
>> +     struct drm_i915_query_cs_cycles query;
>> +     struct intel_engine_cs *engine;
>> +     __ktime_func_t cpu_clock;
>> +     int ret;
>> +
>> +     if (GRAPHICS_VER(i915) < 6)
>> +             return -ENODEV;
>> +
>> +     query_ptr = u64_to_user_ptr(query_item->data_ptr);
>> +     ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
>> +     if (ret != 0)
>> +             return ret;
>> +
>> +     if (query.flags)
>> +             return -EINVAL;
>> +
>> +     if (query.rsvd)
>> +             return -EINVAL;
>> +
>> +     cpu_clock = __clock_id_to_func(query.clockid);
>> +     if (!cpu_clock)
>> +             return -EINVAL;
>> +
>> +     engine = intel_engine_lookup_user(i915,
>> +                                       query.engine.engine_class,
>> +                                       query.engine.engine_instance);
>> +     if (!engine)
>> +             return -EINVAL;
>> +
>> +     if (GRAPHICS_VER(i915) == 6 &&
>> +         query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>> +             return -ENODEV;
>> +
>> +     query.cs_frequency = engine->gt->clock_frequency;
>> +     ret = __query_cs_cycles(engine,
>> +                             &query.cs_cycles,
>> +                             query.cpu_timestamp,
>> +                             cpu_clock);
>> +     if (ret)
>> +             return ret;
>> +
>> +     if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
>> +             return -EFAULT;
>> +
>> +     if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
>> +             return -EFAULT;
>> +
>> +     if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
>> +             return -EFAULT;
>> +
>> +     if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
>> +             return -EFAULT;
>> +
>> +     return sizeof(query);
>> +}
>> +
>>   static int
>>   query_engine_info(struct drm_i915_private *i915,
>>                  struct drm_i915_query_item *query_item)
>> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>>        query_topology_info,
>>        query_engine_info,
>>        query_perf_config,
>> +     query_cs_cycles,
>>   };
>>
>>   int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
>> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
>> index 6a34243a7646..08b00f1709b5 100644
>> --- a/include/uapi/drm/i915_drm.h
>> +++ b/include/uapi/drm/i915_drm.h
>> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>>   #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>>   #define DRM_I915_QUERY_ENGINE_INFO   2
>>   #define DRM_I915_QUERY_PERF_CONFIG      3
>> +     /**
>> +      * Query Command Streamer timestamp register.
>> +      */
>> +#define DRM_I915_QUERY_CS_CYCLES     4
>>   /* Must be kept compact -- no holes and well documented */
>>
>>        /**
>> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>>        __u64 rsvd1[4];
>>   };
>>
>> +/**
>> + * struct drm_i915_query_cs_cycles
>> + *
>> + * The query returns the command streamer cycles and the frequency that can be
>> + * used to calculate the command streamer timestamp. In addition the query
>> + * returns a set of cpu timestamps that indicate when the command streamer cycle
>> + * count was captured.
>> + */
>> +struct drm_i915_query_cs_cycles {
>> +     /** Engine for which command streamer cycles is queried. */
>> +     struct i915_engine_class_instance engine;
>>
>> Why is this per-engine?  Do we actually expect it to change between
>> engines?
>>
>>
>> Each engine has its own timestamp register.
>>
>>
>>    If so, we may have a problem because Vulkan expects a
>> unified timestamp domain for all command streamer timestamp queries.
>>
>>
>> I don't think it does : "
>>
>> Timestamps may only be meaningfully compared if they are written by commands submitted to the same queue.
> Yes but vkGetCalibratedTimestampsEXT() doesn't take a queue or even a
> queue family.


I know, I brought up the issue recently. See khronos issue 2551.

You might not like the resolution... I did propose to do a rev2 of the 
extension to let the user specify the queue.

We can still do that in the future.


>    Also, VkPhysicalDeviceLimits::timestampPeriod gives a
> single timestampPeriod for all queues.


That is fine for us, we should have the same period on all command 
streamers.


-Lionel


>    It's possible that Vulkan
> messed up real bad there but I thought we did a HW survey at the time
> and determined that it was ok.
>
> --Jason
>
>
>> " [1]
>>
>>
>> [1] : https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html
>>
>>
>> -Lionel
>>
>>
>>
>> --Jason
>>
>>
>> +     /** Must be zero. */
>> +     __u32 flags;
>> +
>> +     /**
>> +      * Command streamer cycles as read from the command streamer
>> +      * register at 0x358 offset.
>> +      */
>> +     __u64 cs_cycles;
>> +
>> +     /** Frequency of the cs cycles in Hz. */
>> +     __u64 cs_frequency;
>> +
>> +     /**
>> +      * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
>> +      * cs_cycles register using the reference clockid set by the user.
>> +      * cpu_timestamp[1] is the time taken in ns to read the lower dword of
>> +      * the cs_cycles register.
>> +      */
>> +     __u64 cpu_timestamp[2];
>> +
>> +     /**
>> +      * Reference clock id for CPU timestamp. For definition, see
>> +      * clock_gettime(2) and perf_event_open(2). Supported clock ids are
>> +      * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
>> +      * CLOCK_TAI.
>> +      */
>> +     __s32 clockid;
>> +
>> +     /** Must be zero. */
>> +     __u32 rsvd;
>> +};
>> +
>>   /**
>>    * struct drm_i915_query_engine_info
>>    *
>>
>> --
>> Jani Nikula, Intel Open Source Graphics Center
>>
>>

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Lionel Landwerlin]

On 28/04/2021 23:14, Lionel Landwerlin wrote:
> On 28/04/2021 22:54, Jason Ekstrand wrote:
>> On Wed, Apr 28, 2021 at 2:50 PM Lionel Landwerlin
>> <lionel.g.landwerlin@intel.com> wrote:
>>> On 28/04/2021 22:24, Jason Ekstrand wrote:
>>>
>>> On Wed, Apr 28, 2021 at 3:43 AM Jani Nikula 
>>> <jani.nikula@linux.intel.com> wrote:
>>>
>>> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa 
>>> <umesh.nerlige.ramappa@intel.com> wrote:
>>>
>>> Perf measurements rely on CPU and engine timestamps to correlate
>>> events of interest across these time domains. Current mechanisms get
>>> these timestamps separately and the calculated delta between these
>>> timestamps lack enough accuracy.
>>>
>>> To improve the accuracy of these time measurements to within a few us,
>>> add a query that returns the engine and cpu timestamps captured as
>>> close to each other as possible.
>>>
>>> Cc: dri-devel, Jason and Daniel for review.
>>>
>>> Thanks!
>>>
>>> v2: (Tvrtko)
>>> - document clock reference used
>>> - return cpu timestamp always
>>> - capture cpu time just before lower dword of cs timestamp
>>>
>>> v3: (Chris)
>>> - use uncore-rpm
>>> - use __query_cs_timestamp helper
>>>
>>> v4: (Lionel)
>>> - Kernel perf subsytem allows users to specify the clock id to be used
>>>    in perf_event_open. This clock id is used by the perf subsystem to
>>>    return the appropriate cpu timestamp in perf events. Similarly, let
>>>    the user pass the clockid to this query so that cpu timestamp
>>>    corresponds to the clock id requested.
>>>
>>> v5: (Tvrtko)
>>> - Use normal ktime accessors instead of fast versions
>>> - Add more uApi documentation
>>>
>>> v6: (Lionel)
>>> - Move switch out of spinlock
>>>
>>> v7: (Chris)
>>> - cs_timestamp is a misnomer, use cs_cycles instead
>>> - return the cs cycle frequency as well in the query
>>>
>>> v8:
>>> - Add platform and engine specific checks
>>>
>>> v9: (Lionel)
>>> - Return 2 cpu timestamps in the query - captured before and after the
>>>    register read
>>>
>>> v10: (Chris)
>>> - Use local_clock() to measure time taken to read lower dword of
>>>    register and return it to user.
>>>
>>> v11: (Jani)
>>> - IS_GEN deprecated. User GRAPHICS_VER instead.
>>>
>>> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
>>> ---
>>>   drivers/gpu/drm/i915/i915_query.c | 145 
>>> ++++++++++++++++++++++++++++++
>>>   include/uapi/drm/i915_drm.h       |  48 ++++++++++
>>>   2 files changed, 193 insertions(+)
>>>
>>> diff --git a/drivers/gpu/drm/i915/i915_query.c 
>>> b/drivers/gpu/drm/i915/i915_query.c
>>> index fed337ad7b68..2594b93901ac 100644
>>> --- a/drivers/gpu/drm/i915/i915_query.c
>>> +++ b/drivers/gpu/drm/i915/i915_query.c
>>> @@ -6,6 +6,8 @@
>>>
>>>   #include <linux/nospec.h>
>>>
>>> +#include "gt/intel_engine_pm.h"
>>> +#include "gt/intel_engine_user.h"
>>>   #include "i915_drv.h"
>>>   #include "i915_perf.h"
>>>   #include "i915_query.h"
>>> @@ -90,6 +92,148 @@ static int query_topology_info(struct 
>>> drm_i915_private *dev_priv,
>>>        return total_length;
>>>   }
>>>
>>> +typedef u64 (*__ktime_func_t)(void);
>>> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
>>> +{
>>> +     /*
>>> +      * Use logic same as the perf subsystem to allow user to 
>>> select the
>>> +      * reference clock id to be used for timestamps.
>>> +      */
>>> +     switch (clk_id) {
>>> +     case CLOCK_MONOTONIC:
>>> +             return &ktime_get_ns;
>>> +     case CLOCK_MONOTONIC_RAW:
>>> +             return &ktime_get_raw_ns;
>>> +     case CLOCK_REALTIME:
>>> +             return &ktime_get_real_ns;
>>> +     case CLOCK_BOOTTIME:
>>> +             return &ktime_get_boottime_ns;
>>> +     case CLOCK_TAI:
>>> +             return &ktime_get_clocktai_ns;
>>> +     default:
>>> +             return NULL;
>>> +     }
>>> +}
>>> +
>>> +static inline int
>>> +__read_timestamps(struct intel_uncore *uncore,
>>> +               i915_reg_t lower_reg,
>>> +               i915_reg_t upper_reg,
>>> +               u64 *cs_ts,
>>> +               u64 *cpu_ts,
>>> +               __ktime_func_t cpu_clock)
>>> +{
>>> +     u32 upper, lower, old_upper, loop = 0;
>>> +
>>> +     upper = intel_uncore_read_fw(uncore, upper_reg);
>>> +     do {
>>> +             cpu_ts[1] = local_clock();
>>> +             cpu_ts[0] = cpu_clock();
>>> +             lower = intel_uncore_read_fw(uncore, lower_reg);
>>> +             cpu_ts[1] = local_clock() - cpu_ts[1];
>>> +             old_upper = upper;
>>> +             upper = intel_uncore_read_fw(uncore, upper_reg);
>>> +     } while (upper != old_upper && loop++ < 2);
>>> +
>>> +     *cs_ts = (u64)upper << 32 | lower;
>>> +
>>> +     return 0;
>>> +}
>>> +
>>> +static int
>>> +__query_cs_cycles(struct intel_engine_cs *engine,
>>> +               u64 *cs_ts, u64 *cpu_ts,
>>> +               __ktime_func_t cpu_clock)
>>> +{
>>> +     struct intel_uncore *uncore = engine->uncore;
>>> +     enum forcewake_domains fw_domains;
>>> +     u32 base = engine->mmio_base;
>>> +     intel_wakeref_t wakeref;
>>> +     int ret;
>>> +
>>> +     fw_domains = intel_uncore_forcewake_for_reg(uncore,
>>> + RING_TIMESTAMP(base),
>>> + FW_REG_READ);
>>> +
>>> +     with_intel_runtime_pm(uncore->rpm, wakeref) {
>>> +             spin_lock_irq(&uncore->lock);
>>> +             intel_uncore_forcewake_get__locked(uncore, fw_domains);
>>> +
>>> +             ret = __read_timestamps(uncore,
>>> +                                     RING_TIMESTAMP(base),
>>> + RING_TIMESTAMP_UDW(base),
>>> +                                     cs_ts,
>>> +                                     cpu_ts,
>>> +                                     cpu_clock);
>>> +
>>> +             intel_uncore_forcewake_put__locked(uncore, fw_domains);
>>> +             spin_unlock_irq(&uncore->lock);
>>> +     }
>>> +
>>> +     return ret;
>>> +}
>>> +
>>> +static int
>>> +query_cs_cycles(struct drm_i915_private *i915,
>>> +             struct drm_i915_query_item *query_item)
>>> +{
>>> +     struct drm_i915_query_cs_cycles __user *query_ptr;
>>> +     struct drm_i915_query_cs_cycles query;
>>> +     struct intel_engine_cs *engine;
>>> +     __ktime_func_t cpu_clock;
>>> +     int ret;
>>> +
>>> +     if (GRAPHICS_VER(i915) < 6)
>>> +             return -ENODEV;
>>> +
>>> +     query_ptr = u64_to_user_ptr(query_item->data_ptr);
>>> +     ret = copy_query_item(&query, sizeof(query), sizeof(query), 
>>> query_item);
>>> +     if (ret != 0)
>>> +             return ret;
>>> +
>>> +     if (query.flags)
>>> +             return -EINVAL;
>>> +
>>> +     if (query.rsvd)
>>> +             return -EINVAL;
>>> +
>>> +     cpu_clock = __clock_id_to_func(query.clockid);
>>> +     if (!cpu_clock)
>>> +             return -EINVAL;
>>> +
>>> +     engine = intel_engine_lookup_user(i915,
>>> + query.engine.engine_class,
>>> + query.engine.engine_instance);
>>> +     if (!engine)
>>> +             return -EINVAL;
>>> +
>>> +     if (GRAPHICS_VER(i915) == 6 &&
>>> +         query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>>> +             return -ENODEV;
>>> +
>>> +     query.cs_frequency = engine->gt->clock_frequency;
>>> +     ret = __query_cs_cycles(engine,
>>> +                             &query.cs_cycles,
>>> +                             query.cpu_timestamp,
>>> +                             cpu_clock);
>>> +     if (ret)
>>> +             return ret;
>>> +
>>> +     if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
>>> +             return -EFAULT;
>>> +
>>> +     if (put_user(query.cpu_timestamp[0], 
>>> &query_ptr->cpu_timestamp[0]))
>>> +             return -EFAULT;
>>> +
>>> +     if (put_user(query.cpu_timestamp[1], 
>>> &query_ptr->cpu_timestamp[1]))
>>> +             return -EFAULT;
>>> +
>>> +     if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
>>> +             return -EFAULT;
>>> +
>>> +     return sizeof(query);
>>> +}
>>> +
>>>   static int
>>>   query_engine_info(struct drm_i915_private *i915,
>>>                  struct drm_i915_query_item *query_item)
>>> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct 
>>> drm_i915_private *dev_priv,
>>>        query_topology_info,
>>>        query_engine_info,
>>>        query_perf_config,
>>> +     query_cs_cycles,
>>>   };
>>>
>>>   int i915_query_ioctl(struct drm_device *dev, void *data, struct 
>>> drm_file *file)
>>> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
>>> index 6a34243a7646..08b00f1709b5 100644
>>> --- a/include/uapi/drm/i915_drm.h
>>> +++ b/include/uapi/drm/i915_drm.h
>>> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>>>   #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>>>   #define DRM_I915_QUERY_ENGINE_INFO   2
>>>   #define DRM_I915_QUERY_PERF_CONFIG      3
>>> +     /**
>>> +      * Query Command Streamer timestamp register.
>>> +      */
>>> +#define DRM_I915_QUERY_CS_CYCLES     4
>>>   /* Must be kept compact -- no holes and well documented */
>>>
>>>        /**
>>> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>>>        __u64 rsvd1[4];
>>>   };
>>>
>>> +/**
>>> + * struct drm_i915_query_cs_cycles
>>> + *
>>> + * The query returns the command streamer cycles and the frequency 
>>> that can be
>>> + * used to calculate the command streamer timestamp. In addition 
>>> the query
>>> + * returns a set of cpu timestamps that indicate when the command 
>>> streamer cycle
>>> + * count was captured.
>>> + */
>>> +struct drm_i915_query_cs_cycles {
>>> +     /** Engine for which command streamer cycles is queried. */
>>> +     struct i915_engine_class_instance engine;
>>>
>>> Why is this per-engine?  Do we actually expect it to change between
>>> engines?
>>>
>>>
>>> Each engine has its own timestamp register.
>>>
>>>
>>>    If so, we may have a problem because Vulkan expects a
>>> unified timestamp domain for all command streamer timestamp queries.
>>>
>>>
>>> I don't think it does : "
>>>
>>> Timestamps may only be meaningfully compared if they are written by 
>>> commands submitted to the same queue.
>> Yes but vkGetCalibratedTimestampsEXT() doesn't take a queue or even a
>> queue family.
>
>
> I know, I brought up the issue recently. See khronos issue 2551.
>
> You might not like the resolution... I did propose to do a rev2 of the 
> extension to let the user specify the queue.
>
> We can still do that in the future.
>
>
>>    Also, VkPhysicalDeviceLimits::timestampPeriod gives a
>> single timestampPeriod for all queues.
>
>
> That is fine for us, we should have the same period on all command 
> streamers.
>
>
> -Lionel


Here is the Mesa MR using this extension btw : 
https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/9407


-Lionel


>
>
>>    It's possible that Vulkan
>> messed up real bad there but I thought we did a HW survey at the time
>> and determined that it was ok.
>>
>> --Jason
>>
>>
>>> " [1]
>>>
>>>
>>> [1] : 
>>> https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html
>>>
>>>
>>> -Lionel
>>>
>>>
>>>
>>> --Jason
>>>
>>>
>>> +     /** Must be zero. */
>>> +     __u32 flags;
>>> +
>>> +     /**
>>> +      * Command streamer cycles as read from the command streamer
>>> +      * register at 0x358 offset.
>>> +      */
>>> +     __u64 cs_cycles;
>>> +
>>> +     /** Frequency of the cs cycles in Hz. */
>>> +     __u64 cs_frequency;
>>> +
>>> +     /**
>>> +      * CPU timestamps in ns. cpu_timestamp[0] is captured before 
>>> reading the
>>> +      * cs_cycles register using the reference clockid set by the 
>>> user.
>>> +      * cpu_timestamp[1] is the time taken in ns to read the lower 
>>> dword of
>>> +      * the cs_cycles register.
>>> +      */
>>> +     __u64 cpu_timestamp[2];
>>> +
>>> +     /**
>>> +      * Reference clock id for CPU timestamp. For definition, see
>>> +      * clock_gettime(2) and perf_event_open(2). Supported clock 
>>> ids are
>>> +      * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, 
>>> CLOCK_BOOTTIME,
>>> +      * CLOCK_TAI.
>>> +      */
>>> +     __s32 clockid;
>>> +
>>> +     /** Must be zero. */
>>> +     __u32 rsvd;
>>> +};
>>> +
>>>   /**
>>>    * struct drm_i915_query_engine_info
>>>    *
>>>
>>> -- 
>>> Jani Nikula, Intel Open Source Graphics Center
>>>
>>>
>
> _______________________________________________
> dri-devel mailing list
> dri-devel@lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/dri-devel


_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jason Ekstrand]

On Wed, Apr 28, 2021 at 3:14 PM Lionel Landwerlin
<lionel.g.landwerlin@intel.com> wrote:
>
> On 28/04/2021 22:54, Jason Ekstrand wrote:
> > On Wed, Apr 28, 2021 at 2:50 PM Lionel Landwerlin
> > <lionel.g.landwerlin@intel.com> wrote:
> >> On 28/04/2021 22:24, Jason Ekstrand wrote:
> >>
> >> On Wed, Apr 28, 2021 at 3:43 AM Jani Nikula <jani.nikula@linux.intel.com> wrote:
> >>
> >> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
> >>
> >> Perf measurements rely on CPU and engine timestamps to correlate
> >> events of interest across these time domains. Current mechanisms get
> >> these timestamps separately and the calculated delta between these
> >> timestamps lack enough accuracy.
> >>
> >> To improve the accuracy of these time measurements to within a few us,
> >> add a query that returns the engine and cpu timestamps captured as
> >> close to each other as possible.
> >>
> >> Cc: dri-devel, Jason and Daniel for review.
> >>
> >> Thanks!
> >>
> >> v2: (Tvrtko)
> >> - document clock reference used
> >> - return cpu timestamp always
> >> - capture cpu time just before lower dword of cs timestamp
> >>
> >> v3: (Chris)
> >> - use uncore-rpm
> >> - use __query_cs_timestamp helper
> >>
> >> v4: (Lionel)
> >> - Kernel perf subsytem allows users to specify the clock id to be used
> >>    in perf_event_open. This clock id is used by the perf subsystem to
> >>    return the appropriate cpu timestamp in perf events. Similarly, let
> >>    the user pass the clockid to this query so that cpu timestamp
> >>    corresponds to the clock id requested.
> >>
> >> v5: (Tvrtko)
> >> - Use normal ktime accessors instead of fast versions
> >> - Add more uApi documentation
> >>
> >> v6: (Lionel)
> >> - Move switch out of spinlock
> >>
> >> v7: (Chris)
> >> - cs_timestamp is a misnomer, use cs_cycles instead
> >> - return the cs cycle frequency as well in the query
> >>
> >> v8:
> >> - Add platform and engine specific checks
> >>
> >> v9: (Lionel)
> >> - Return 2 cpu timestamps in the query - captured before and after the
> >>    register read
> >>
> >> v10: (Chris)
> >> - Use local_clock() to measure time taken to read lower dword of
> >>    register and return it to user.
> >>
> >> v11: (Jani)
> >> - IS_GEN deprecated. User GRAPHICS_VER instead.
> >>
> >> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> >> ---
> >>   drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
> >>   include/uapi/drm/i915_drm.h       |  48 ++++++++++
> >>   2 files changed, 193 insertions(+)
> >>
> >> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> >> index fed337ad7b68..2594b93901ac 100644
> >> --- a/drivers/gpu/drm/i915/i915_query.c
> >> +++ b/drivers/gpu/drm/i915/i915_query.c
> >> @@ -6,6 +6,8 @@
> >>
> >>   #include <linux/nospec.h>
> >>
> >> +#include "gt/intel_engine_pm.h"
> >> +#include "gt/intel_engine_user.h"
> >>   #include "i915_drv.h"
> >>   #include "i915_perf.h"
> >>   #include "i915_query.h"
> >> @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
> >>        return total_length;
> >>   }
> >>
> >> +typedef u64 (*__ktime_func_t)(void);
> >> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> >> +{
> >> +     /*
> >> +      * Use logic same as the perf subsystem to allow user to select the
> >> +      * reference clock id to be used for timestamps.
> >> +      */
> >> +     switch (clk_id) {
> >> +     case CLOCK_MONOTONIC:
> >> +             return &ktime_get_ns;
> >> +     case CLOCK_MONOTONIC_RAW:
> >> +             return &ktime_get_raw_ns;
> >> +     case CLOCK_REALTIME:
> >> +             return &ktime_get_real_ns;
> >> +     case CLOCK_BOOTTIME:
> >> +             return &ktime_get_boottime_ns;
> >> +     case CLOCK_TAI:
> >> +             return &ktime_get_clocktai_ns;
> >> +     default:
> >> +             return NULL;
> >> +     }
> >> +}
> >> +
> >> +static inline int
> >> +__read_timestamps(struct intel_uncore *uncore,
> >> +               i915_reg_t lower_reg,
> >> +               i915_reg_t upper_reg,
> >> +               u64 *cs_ts,
> >> +               u64 *cpu_ts,
> >> +               __ktime_func_t cpu_clock)
> >> +{
> >> +     u32 upper, lower, old_upper, loop = 0;
> >> +
> >> +     upper = intel_uncore_read_fw(uncore, upper_reg);
> >> +     do {
> >> +             cpu_ts[1] = local_clock();
> >> +             cpu_ts[0] = cpu_clock();
> >> +             lower = intel_uncore_read_fw(uncore, lower_reg);
> >> +             cpu_ts[1] = local_clock() - cpu_ts[1];
> >> +             old_upper = upper;
> >> +             upper = intel_uncore_read_fw(uncore, upper_reg);
> >> +     } while (upper != old_upper && loop++ < 2);
> >> +
> >> +     *cs_ts = (u64)upper << 32 | lower;
> >> +
> >> +     return 0;
> >> +}
> >> +
> >> +static int
> >> +__query_cs_cycles(struct intel_engine_cs *engine,
> >> +               u64 *cs_ts, u64 *cpu_ts,
> >> +               __ktime_func_t cpu_clock)
> >> +{
> >> +     struct intel_uncore *uncore = engine->uncore;
> >> +     enum forcewake_domains fw_domains;
> >> +     u32 base = engine->mmio_base;
> >> +     intel_wakeref_t wakeref;
> >> +     int ret;
> >> +
> >> +     fw_domains = intel_uncore_forcewake_for_reg(uncore,
> >> +                                                 RING_TIMESTAMP(base),
> >> +                                                 FW_REG_READ);
> >> +
> >> +     with_intel_runtime_pm(uncore->rpm, wakeref) {
> >> +             spin_lock_irq(&uncore->lock);
> >> +             intel_uncore_forcewake_get__locked(uncore, fw_domains);
> >> +
> >> +             ret = __read_timestamps(uncore,
> >> +                                     RING_TIMESTAMP(base),
> >> +                                     RING_TIMESTAMP_UDW(base),
> >> +                                     cs_ts,
> >> +                                     cpu_ts,
> >> +                                     cpu_clock);
> >> +
> >> +             intel_uncore_forcewake_put__locked(uncore, fw_domains);
> >> +             spin_unlock_irq(&uncore->lock);
> >> +     }
> >> +
> >> +     return ret;
> >> +}
> >> +
> >> +static int
> >> +query_cs_cycles(struct drm_i915_private *i915,
> >> +             struct drm_i915_query_item *query_item)
> >> +{
> >> +     struct drm_i915_query_cs_cycles __user *query_ptr;
> >> +     struct drm_i915_query_cs_cycles query;
> >> +     struct intel_engine_cs *engine;
> >> +     __ktime_func_t cpu_clock;
> >> +     int ret;
> >> +
> >> +     if (GRAPHICS_VER(i915) < 6)
> >> +             return -ENODEV;
> >> +
> >> +     query_ptr = u64_to_user_ptr(query_item->data_ptr);
> >> +     ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> >> +     if (ret != 0)
> >> +             return ret;
> >> +
> >> +     if (query.flags)
> >> +             return -EINVAL;
> >> +
> >> +     if (query.rsvd)
> >> +             return -EINVAL;
> >> +
> >> +     cpu_clock = __clock_id_to_func(query.clockid);
> >> +     if (!cpu_clock)
> >> +             return -EINVAL;
> >> +
> >> +     engine = intel_engine_lookup_user(i915,
> >> +                                       query.engine.engine_class,
> >> +                                       query.engine.engine_instance);
> >> +     if (!engine)
> >> +             return -EINVAL;
> >> +
> >> +     if (GRAPHICS_VER(i915) == 6 &&
> >> +         query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> >> +             return -ENODEV;
> >> +
> >> +     query.cs_frequency = engine->gt->clock_frequency;
> >> +     ret = __query_cs_cycles(engine,
> >> +                             &query.cs_cycles,
> >> +                             query.cpu_timestamp,
> >> +                             cpu_clock);
> >> +     if (ret)
> >> +             return ret;
> >> +
> >> +     if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> >> +             return -EFAULT;
> >> +
> >> +     if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
> >> +             return -EFAULT;
> >> +
> >> +     if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
> >> +             return -EFAULT;
> >> +
> >> +     if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> >> +             return -EFAULT;
> >> +
> >> +     return sizeof(query);
> >> +}
> >> +
> >>   static int
> >>   query_engine_info(struct drm_i915_private *i915,
> >>                  struct drm_i915_query_item *query_item)
> >> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
> >>        query_topology_info,
> >>        query_engine_info,
> >>        query_perf_config,
> >> +     query_cs_cycles,
> >>   };
> >>
> >>   int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> >> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> >> index 6a34243a7646..08b00f1709b5 100644
> >> --- a/include/uapi/drm/i915_drm.h
> >> +++ b/include/uapi/drm/i915_drm.h
> >> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
> >>   #define DRM_I915_QUERY_TOPOLOGY_INFO    1
> >>   #define DRM_I915_QUERY_ENGINE_INFO   2
> >>   #define DRM_I915_QUERY_PERF_CONFIG      3
> >> +     /**
> >> +      * Query Command Streamer timestamp register.
> >> +      */
> >> +#define DRM_I915_QUERY_CS_CYCLES     4
> >>   /* Must be kept compact -- no holes and well documented */
> >>
> >>        /**
> >> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
> >>        __u64 rsvd1[4];
> >>   };
> >>
> >> +/**
> >> + * struct drm_i915_query_cs_cycles
> >> + *
> >> + * The query returns the command streamer cycles and the frequency that can be
> >> + * used to calculate the command streamer timestamp. In addition the query
> >> + * returns a set of cpu timestamps that indicate when the command streamer cycle
> >> + * count was captured.
> >> + */
> >> +struct drm_i915_query_cs_cycles {
> >> +     /** Engine for which command streamer cycles is queried. */
> >> +     struct i915_engine_class_instance engine;
> >>
> >> Why is this per-engine?  Do we actually expect it to change between
> >> engines?
> >>
> >>
> >> Each engine has its own timestamp register.
> >>
> >>
> >>    If so, we may have a problem because Vulkan expects a
> >> unified timestamp domain for all command streamer timestamp queries.
> >>
> >>
> >> I don't think it does : "
> >>
> >> Timestamps may only be meaningfully compared if they are written by commands submitted to the same queue.
> > Yes but vkGetCalibratedTimestampsEXT() doesn't take a queue or even a
> > queue family.
>
>
> I know, I brought up the issue recently. See khronos issue 2551.

I guess this is what I get for not attending the Vulkan SI call
anymore.  Small price to pay....

So the answer is that we just stop exposing the DEVICE time domain as
soon as we start using anything other than RENDER?  Seems a bit rough
but should be doable.

> You might not like the resolution... I did propose to do a rev2 of the
> extension to let the user specify the queue.
>
> We can still do that in the future.

Yeah, I think we'll want to do something if we care about this
extension.  One option would be to make it take a queue family.
Another would be to expose it as one domain per queue family.
Anyway... that's a discussion for another forum.

> >    Also, VkPhysicalDeviceLimits::timestampPeriod gives a
> > single timestampPeriod for all queues.
>
>
> That is fine for us, we should have the same period on all command
> streamers.

I guess I've got no problem returning the period as part of this
query.  ANV should probably assert that it's what it expects, though.

> -Lionel
>
>
> >    It's possible that Vulkan
> > messed up real bad there but I thought we did a HW survey at the time
> > and determined that it was ok.
> >
> > --Jason
> >
> >
> >> " [1]
> >>
> >>
> >> [1] : https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html
> >>
> >>
> >> -Lionel
> >>
> >>
> >>
> >> --Jason
> >>
> >>
> >> +     /** Must be zero. */
> >> +     __u32 flags;
> >> +
> >> +     /**
> >> +      * Command streamer cycles as read from the command streamer
> >> +      * register at 0x358 offset.
> >> +      */
> >> +     __u64 cs_cycles;
> >> +
> >> +     /** Frequency of the cs cycles in Hz. */
> >> +     __u64 cs_frequency;
> >> +
> >> +     /**
> >> +      * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
> >> +      * cs_cycles register using the reference clockid set by the user.
> >> +      * cpu_timestamp[1] is the time taken in ns to read the lower dword of
> >> +      * the cs_cycles register.
> >> +      */
> >> +     __u64 cpu_timestamp[2];

I think the API would be more clear if we had separate cpu_timestamp
and cpu_delta fields or something like that.  That or make
cpu_timestamp[1] the end time rather than a delta.  It's weird to have
an array where the first entry is absolute and the second entry is a
delta.

--Jason


> >> +
> >> +     /**
> >> +      * Reference clock id for CPU timestamp. For definition, see
> >> +      * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> >> +      * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> >> +      * CLOCK_TAI.
> >> +      */
> >> +     __s32 clockid;
> >> +
> >> +     /** Must be zero. */
> >> +     __u32 rsvd;
> >> +};
> >> +
> >>   /**
> >>    * struct drm_i915_query_engine_info
> >>    *
> >>
> >> --
> >> Jani Nikula, Intel Open Source Graphics Center
> >>
> >>
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Lionel Landwerlin]

On 28/04/2021 23:45, Jason Ekstrand wrote:
> On Wed, Apr 28, 2021 at 3:14 PM Lionel Landwerlin
> <lionel.g.landwerlin@intel.com> wrote:
>> On 28/04/2021 22:54, Jason Ekstrand wrote:
>>> On Wed, Apr 28, 2021 at 2:50 PM Lionel Landwerlin
>>> <lionel.g.landwerlin@intel.com> wrote:
>>>> On 28/04/2021 22:24, Jason Ekstrand wrote:
>>>>
>>>> On Wed, Apr 28, 2021 at 3:43 AM Jani Nikula <jani.nikula@linux.intel.com> wrote:
>>>>
>>>> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
>>>>
>>>> Perf measurements rely on CPU and engine timestamps to correlate
>>>> events of interest across these time domains. Current mechanisms get
>>>> these timestamps separately and the calculated delta between these
>>>> timestamps lack enough accuracy.
>>>>
>>>> To improve the accuracy of these time measurements to within a few us,
>>>> add a query that returns the engine and cpu timestamps captured as
>>>> close to each other as possible.
>>>>
>>>> Cc: dri-devel, Jason and Daniel for review.
>>>>
>>>> Thanks!
>>>>
>>>> v2: (Tvrtko)
>>>> - document clock reference used
>>>> - return cpu timestamp always
>>>> - capture cpu time just before lower dword of cs timestamp
>>>>
>>>> v3: (Chris)
>>>> - use uncore-rpm
>>>> - use __query_cs_timestamp helper
>>>>
>>>> v4: (Lionel)
>>>> - Kernel perf subsytem allows users to specify the clock id to be used
>>>>     in perf_event_open. This clock id is used by the perf subsystem to
>>>>     return the appropriate cpu timestamp in perf events. Similarly, let
>>>>     the user pass the clockid to this query so that cpu timestamp
>>>>     corresponds to the clock id requested.
>>>>
>>>> v5: (Tvrtko)
>>>> - Use normal ktime accessors instead of fast versions
>>>> - Add more uApi documentation
>>>>
>>>> v6: (Lionel)
>>>> - Move switch out of spinlock
>>>>
>>>> v7: (Chris)
>>>> - cs_timestamp is a misnomer, use cs_cycles instead
>>>> - return the cs cycle frequency as well in the query
>>>>
>>>> v8:
>>>> - Add platform and engine specific checks
>>>>
>>>> v9: (Lionel)
>>>> - Return 2 cpu timestamps in the query - captured before and after the
>>>>     register read
>>>>
>>>> v10: (Chris)
>>>> - Use local_clock() to measure time taken to read lower dword of
>>>>     register and return it to user.
>>>>
>>>> v11: (Jani)
>>>> - IS_GEN deprecated. User GRAPHICS_VER instead.
>>>>
>>>> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
>>>> ---
>>>>    drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>>>>    include/uapi/drm/i915_drm.h       |  48 ++++++++++
>>>>    2 files changed, 193 insertions(+)
>>>>
>>>> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
>>>> index fed337ad7b68..2594b93901ac 100644
>>>> --- a/drivers/gpu/drm/i915/i915_query.c
>>>> +++ b/drivers/gpu/drm/i915/i915_query.c
>>>> @@ -6,6 +6,8 @@
>>>>
>>>>    #include <linux/nospec.h>
>>>>
>>>> +#include "gt/intel_engine_pm.h"
>>>> +#include "gt/intel_engine_user.h"
>>>>    #include "i915_drv.h"
>>>>    #include "i915_perf.h"
>>>>    #include "i915_query.h"
>>>> @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>>>>         return total_length;
>>>>    }
>>>>
>>>> +typedef u64 (*__ktime_func_t)(void);
>>>> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
>>>> +{
>>>> +     /*
>>>> +      * Use logic same as the perf subsystem to allow user to select the
>>>> +      * reference clock id to be used for timestamps.
>>>> +      */
>>>> +     switch (clk_id) {
>>>> +     case CLOCK_MONOTONIC:
>>>> +             return &ktime_get_ns;
>>>> +     case CLOCK_MONOTONIC_RAW:
>>>> +             return &ktime_get_raw_ns;
>>>> +     case CLOCK_REALTIME:
>>>> +             return &ktime_get_real_ns;
>>>> +     case CLOCK_BOOTTIME:
>>>> +             return &ktime_get_boottime_ns;
>>>> +     case CLOCK_TAI:
>>>> +             return &ktime_get_clocktai_ns;
>>>> +     default:
>>>> +             return NULL;
>>>> +     }
>>>> +}
>>>> +
>>>> +static inline int
>>>> +__read_timestamps(struct intel_uncore *uncore,
>>>> +               i915_reg_t lower_reg,
>>>> +               i915_reg_t upper_reg,
>>>> +               u64 *cs_ts,
>>>> +               u64 *cpu_ts,
>>>> +               __ktime_func_t cpu_clock)
>>>> +{
>>>> +     u32 upper, lower, old_upper, loop = 0;
>>>> +
>>>> +     upper = intel_uncore_read_fw(uncore, upper_reg);
>>>> +     do {
>>>> +             cpu_ts[1] = local_clock();
>>>> +             cpu_ts[0] = cpu_clock();
>>>> +             lower = intel_uncore_read_fw(uncore, lower_reg);
>>>> +             cpu_ts[1] = local_clock() - cpu_ts[1];
>>>> +             old_upper = upper;
>>>> +             upper = intel_uncore_read_fw(uncore, upper_reg);
>>>> +     } while (upper != old_upper && loop++ < 2);
>>>> +
>>>> +     *cs_ts = (u64)upper << 32 | lower;
>>>> +
>>>> +     return 0;
>>>> +}
>>>> +
>>>> +static int
>>>> +__query_cs_cycles(struct intel_engine_cs *engine,
>>>> +               u64 *cs_ts, u64 *cpu_ts,
>>>> +               __ktime_func_t cpu_clock)
>>>> +{
>>>> +     struct intel_uncore *uncore = engine->uncore;
>>>> +     enum forcewake_domains fw_domains;
>>>> +     u32 base = engine->mmio_base;
>>>> +     intel_wakeref_t wakeref;
>>>> +     int ret;
>>>> +
>>>> +     fw_domains = intel_uncore_forcewake_for_reg(uncore,
>>>> +                                                 RING_TIMESTAMP(base),
>>>> +                                                 FW_REG_READ);
>>>> +
>>>> +     with_intel_runtime_pm(uncore->rpm, wakeref) {
>>>> +             spin_lock_irq(&uncore->lock);
>>>> +             intel_uncore_forcewake_get__locked(uncore, fw_domains);
>>>> +
>>>> +             ret = __read_timestamps(uncore,
>>>> +                                     RING_TIMESTAMP(base),
>>>> +                                     RING_TIMESTAMP_UDW(base),
>>>> +                                     cs_ts,
>>>> +                                     cpu_ts,
>>>> +                                     cpu_clock);
>>>> +
>>>> +             intel_uncore_forcewake_put__locked(uncore, fw_domains);
>>>> +             spin_unlock_irq(&uncore->lock);
>>>> +     }
>>>> +
>>>> +     return ret;
>>>> +}
>>>> +
>>>> +static int
>>>> +query_cs_cycles(struct drm_i915_private *i915,
>>>> +             struct drm_i915_query_item *query_item)
>>>> +{
>>>> +     struct drm_i915_query_cs_cycles __user *query_ptr;
>>>> +     struct drm_i915_query_cs_cycles query;
>>>> +     struct intel_engine_cs *engine;
>>>> +     __ktime_func_t cpu_clock;
>>>> +     int ret;
>>>> +
>>>> +     if (GRAPHICS_VER(i915) < 6)
>>>> +             return -ENODEV;
>>>> +
>>>> +     query_ptr = u64_to_user_ptr(query_item->data_ptr);
>>>> +     ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
>>>> +     if (ret != 0)
>>>> +             return ret;
>>>> +
>>>> +     if (query.flags)
>>>> +             return -EINVAL;
>>>> +
>>>> +     if (query.rsvd)
>>>> +             return -EINVAL;
>>>> +
>>>> +     cpu_clock = __clock_id_to_func(query.clockid);
>>>> +     if (!cpu_clock)
>>>> +             return -EINVAL;
>>>> +
>>>> +     engine = intel_engine_lookup_user(i915,
>>>> +                                       query.engine.engine_class,
>>>> +                                       query.engine.engine_instance);
>>>> +     if (!engine)
>>>> +             return -EINVAL;
>>>> +
>>>> +     if (GRAPHICS_VER(i915) == 6 &&
>>>> +         query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>>>> +             return -ENODEV;
>>>> +
>>>> +     query.cs_frequency = engine->gt->clock_frequency;
>>>> +     ret = __query_cs_cycles(engine,
>>>> +                             &query.cs_cycles,
>>>> +                             query.cpu_timestamp,
>>>> +                             cpu_clock);
>>>> +     if (ret)
>>>> +             return ret;
>>>> +
>>>> +     if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
>>>> +             return -EFAULT;
>>>> +
>>>> +     if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
>>>> +             return -EFAULT;
>>>> +
>>>> +     if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
>>>> +             return -EFAULT;
>>>> +
>>>> +     if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
>>>> +             return -EFAULT;
>>>> +
>>>> +     return sizeof(query);
>>>> +}
>>>> +
>>>>    static int
>>>>    query_engine_info(struct drm_i915_private *i915,
>>>>                   struct drm_i915_query_item *query_item)
>>>> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>>>>         query_topology_info,
>>>>         query_engine_info,
>>>>         query_perf_config,
>>>> +     query_cs_cycles,
>>>>    };
>>>>
>>>>    int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
>>>> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
>>>> index 6a34243a7646..08b00f1709b5 100644
>>>> --- a/include/uapi/drm/i915_drm.h
>>>> +++ b/include/uapi/drm/i915_drm.h
>>>> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>>>>    #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>>>>    #define DRM_I915_QUERY_ENGINE_INFO   2
>>>>    #define DRM_I915_QUERY_PERF_CONFIG      3
>>>> +     /**
>>>> +      * Query Command Streamer timestamp register.
>>>> +      */
>>>> +#define DRM_I915_QUERY_CS_CYCLES     4
>>>>    /* Must be kept compact -- no holes and well documented */
>>>>
>>>>         /**
>>>> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>>>>         __u64 rsvd1[4];
>>>>    };
>>>>
>>>> +/**
>>>> + * struct drm_i915_query_cs_cycles
>>>> + *
>>>> + * The query returns the command streamer cycles and the frequency that can be
>>>> + * used to calculate the command streamer timestamp. In addition the query
>>>> + * returns a set of cpu timestamps that indicate when the command streamer cycle
>>>> + * count was captured.
>>>> + */
>>>> +struct drm_i915_query_cs_cycles {
>>>> +     /** Engine for which command streamer cycles is queried. */
>>>> +     struct i915_engine_class_instance engine;
>>>>
>>>> Why is this per-engine?  Do we actually expect it to change between
>>>> engines?
>>>>
>>>>
>>>> Each engine has its own timestamp register.
>>>>
>>>>
>>>>     If so, we may have a problem because Vulkan expects a
>>>> unified timestamp domain for all command streamer timestamp queries.
>>>>
>>>>
>>>> I don't think it does : "
>>>>
>>>> Timestamps may only be meaningfully compared if they are written by commands submitted to the same queue.
>>> Yes but vkGetCalibratedTimestampsEXT() doesn't take a queue or even a
>>> queue family.
>>
>> I know, I brought up the issue recently. See khronos issue 2551.
> I guess this is what I get for not attending the Vulkan SI call
> anymore.  Small price to pay....
>
> So the answer is that we just stop exposing the DEVICE time domain as
> soon as we start using anything other than RENDER?  Seems a bit rough
> but should be doable.
>
>> You might not like the resolution... I did propose to do a rev2 of the
>> extension to let the user specify the queue.
>>
>> We can still do that in the future.
> Yeah, I think we'll want to do something if we care about this
> extension.  One option would be to make it take a queue family.
> Another would be to expose it as one domain per queue family.
> Anyway... that's a discussion for another forum.
>
>>>     Also, VkPhysicalDeviceLimits::timestampPeriod gives a
>>> single timestampPeriod for all queues.
>>
>> That is fine for us, we should have the same period on all command
>> streamers.
> I guess I've got no problem returning the period as part of this
> query.  ANV should probably assert that it's what it expects, though.
>
>> -Lionel
>>
>>
>>>     It's possible that Vulkan
>>> messed up real bad there but I thought we did a HW survey at the time
>>> and determined that it was ok.
>>>
>>> --Jason
>>>
>>>
>>>> " [1]
>>>>
>>>>
>>>> [1] : https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html
>>>>
>>>>
>>>> -Lionel
>>>>
>>>>
>>>>
>>>> --Jason
>>>>
>>>>
>>>> +     /** Must be zero. */
>>>> +     __u32 flags;
>>>> +
>>>> +     /**
>>>> +      * Command streamer cycles as read from the command streamer
>>>> +      * register at 0x358 offset.
>>>> +      */
>>>> +     __u64 cs_cycles;
>>>> +
>>>> +     /** Frequency of the cs cycles in Hz. */
>>>> +     __u64 cs_frequency;
>>>> +
>>>> +     /**
>>>> +      * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
>>>> +      * cs_cycles register using the reference clockid set by the user.
>>>> +      * cpu_timestamp[1] is the time taken in ns to read the lower dword of
>>>> +      * the cs_cycles register.
>>>> +      */
>>>> +     __u64 cpu_timestamp[2];
> I think the API would be more clear if we had separate cpu_timestamp
> and cpu_delta fields or something like that.  That or make
> cpu_timestamp[1] the end time rather than a delta.  It's weird to have
> an array where the first entry is absolute and the second entry is a
> delta.


Oh dear... I did not notice that :(

I thought that was just a little dance to save local variable...

Agreed, 2 different names or 2 snapshots.


-Lionel


>
> --Jason
>
>
>>>> +
>>>> +     /**
>>>> +      * Reference clock id for CPU timestamp. For definition, see
>>>> +      * clock_gettime(2) and perf_event_open(2). Supported clock ids are
>>>> +      * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
>>>> +      * CLOCK_TAI.
>>>> +      */
>>>> +     __s32 clockid;
>>>> +
>>>> +     /** Must be zero. */
>>>> +     __u32 rsvd;
>>>> +};
>>>> +
>>>>    /**
>>>>     * struct drm_i915_query_engine_info
>>>>     *
>>>>
>>>> --
>>>> Jani Nikula, Intel Open Source Graphics Center
>>>>
>>>>

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Daniel Vetter]

On Wed, Apr 28, 2021 at 11:43:22AM +0300, Jani Nikula wrote:
> On Tue, 27 Apr 2021, Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com> wrote:
> > Perf measurements rely on CPU and engine timestamps to correlate
> > events of interest across these time domains. Current mechanisms get
> > these timestamps separately and the calculated delta between these
> > timestamps lack enough accuracy.
> >
> > To improve the accuracy of these time measurements to within a few us,
> > add a query that returns the engine and cpu timestamps captured as
> > close to each other as possible.
> 
> Cc: dri-devel, Jason and Daniel for review.

Yeah going forward pls cc: dri-devel on everything touching
gem/core/scheduler and anything related. Review for these is supposed to
be cc: dri-devel, including anything that's in-flight right now.

Thanks, Daniel

> 
> >
> > v2: (Tvrtko)
> > - document clock reference used
> > - return cpu timestamp always
> > - capture cpu time just before lower dword of cs timestamp
> >
> > v3: (Chris)
> > - use uncore-rpm
> > - use __query_cs_timestamp helper
> >
> > v4: (Lionel)
> > - Kernel perf subsytem allows users to specify the clock id to be used
> >   in perf_event_open. This clock id is used by the perf subsystem to
> >   return the appropriate cpu timestamp in perf events. Similarly, let
> >   the user pass the clockid to this query so that cpu timestamp
> >   corresponds to the clock id requested.
> >
> > v5: (Tvrtko)
> > - Use normal ktime accessors instead of fast versions
> > - Add more uApi documentation
> >
> > v6: (Lionel)
> > - Move switch out of spinlock
> >
> > v7: (Chris)
> > - cs_timestamp is a misnomer, use cs_cycles instead
> > - return the cs cycle frequency as well in the query
> >
> > v8:
> > - Add platform and engine specific checks
> >
> > v9: (Lionel)
> > - Return 2 cpu timestamps in the query - captured before and after the
> >   register read
> >
> > v10: (Chris)
> > - Use local_clock() to measure time taken to read lower dword of
> >   register and return it to user.
> >
> > v11: (Jani)
> > - IS_GEN deprecated. User GRAPHICS_VER instead.
> >
> > Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> > ---
> >  drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
> >  include/uapi/drm/i915_drm.h       |  48 ++++++++++
> >  2 files changed, 193 insertions(+)
> >
> > diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> > index fed337ad7b68..2594b93901ac 100644
> > --- a/drivers/gpu/drm/i915/i915_query.c
> > +++ b/drivers/gpu/drm/i915/i915_query.c
> > @@ -6,6 +6,8 @@
> >  
> >  #include <linux/nospec.h>
> >  
> > +#include "gt/intel_engine_pm.h"
> > +#include "gt/intel_engine_user.h"
> >  #include "i915_drv.h"
> >  #include "i915_perf.h"
> >  #include "i915_query.h"
> > @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
> >  	return total_length;
> >  }
> >  
> > +typedef u64 (*__ktime_func_t)(void);
> > +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> > +{
> > +	/*
> > +	 * Use logic same as the perf subsystem to allow user to select the
> > +	 * reference clock id to be used for timestamps.
> > +	 */
> > +	switch (clk_id) {
> > +	case CLOCK_MONOTONIC:
> > +		return &ktime_get_ns;
> > +	case CLOCK_MONOTONIC_RAW:
> > +		return &ktime_get_raw_ns;
> > +	case CLOCK_REALTIME:
> > +		return &ktime_get_real_ns;
> > +	case CLOCK_BOOTTIME:
> > +		return &ktime_get_boottime_ns;
> > +	case CLOCK_TAI:
> > +		return &ktime_get_clocktai_ns;
> > +	default:
> > +		return NULL;
> > +	}
> > +}
> > +
> > +static inline int
> > +__read_timestamps(struct intel_uncore *uncore,
> > +		  i915_reg_t lower_reg,
> > +		  i915_reg_t upper_reg,
> > +		  u64 *cs_ts,
> > +		  u64 *cpu_ts,
> > +		  __ktime_func_t cpu_clock)
> > +{
> > +	u32 upper, lower, old_upper, loop = 0;
> > +
> > +	upper = intel_uncore_read_fw(uncore, upper_reg);
> > +	do {
> > +		cpu_ts[1] = local_clock();
> > +		cpu_ts[0] = cpu_clock();
> > +		lower = intel_uncore_read_fw(uncore, lower_reg);
> > +		cpu_ts[1] = local_clock() - cpu_ts[1];
> > +		old_upper = upper;
> > +		upper = intel_uncore_read_fw(uncore, upper_reg);
> > +	} while (upper != old_upper && loop++ < 2);
> > +
> > +	*cs_ts = (u64)upper << 32 | lower;
> > +
> > +	return 0;
> > +}
> > +
> > +static int
> > +__query_cs_cycles(struct intel_engine_cs *engine,
> > +		  u64 *cs_ts, u64 *cpu_ts,
> > +		  __ktime_func_t cpu_clock)
> > +{
> > +	struct intel_uncore *uncore = engine->uncore;
> > +	enum forcewake_domains fw_domains;
> > +	u32 base = engine->mmio_base;
> > +	intel_wakeref_t wakeref;
> > +	int ret;
> > +
> > +	fw_domains = intel_uncore_forcewake_for_reg(uncore,
> > +						    RING_TIMESTAMP(base),
> > +						    FW_REG_READ);
> > +
> > +	with_intel_runtime_pm(uncore->rpm, wakeref) {
> > +		spin_lock_irq(&uncore->lock);
> > +		intel_uncore_forcewake_get__locked(uncore, fw_domains);
> > +
> > +		ret = __read_timestamps(uncore,
> > +					RING_TIMESTAMP(base),
> > +					RING_TIMESTAMP_UDW(base),
> > +					cs_ts,
> > +					cpu_ts,
> > +					cpu_clock);
> > +
> > +		intel_uncore_forcewake_put__locked(uncore, fw_domains);
> > +		spin_unlock_irq(&uncore->lock);
> > +	}
> > +
> > +	return ret;
> > +}
> > +
> > +static int
> > +query_cs_cycles(struct drm_i915_private *i915,
> > +		struct drm_i915_query_item *query_item)
> > +{
> > +	struct drm_i915_query_cs_cycles __user *query_ptr;
> > +	struct drm_i915_query_cs_cycles query;
> > +	struct intel_engine_cs *engine;
> > +	__ktime_func_t cpu_clock;
> > +	int ret;
> > +
> > +	if (GRAPHICS_VER(i915) < 6)
> > +		return -ENODEV;
> > +
> > +	query_ptr = u64_to_user_ptr(query_item->data_ptr);
> > +	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> > +	if (ret != 0)
> > +		return ret;
> > +
> > +	if (query.flags)
> > +		return -EINVAL;
> > +
> > +	if (query.rsvd)
> > +		return -EINVAL;
> > +
> > +	cpu_clock = __clock_id_to_func(query.clockid);
> > +	if (!cpu_clock)
> > +		return -EINVAL;
> > +
> > +	engine = intel_engine_lookup_user(i915,
> > +					  query.engine.engine_class,
> > +					  query.engine.engine_instance);
> > +	if (!engine)
> > +		return -EINVAL;
> > +
> > +	if (GRAPHICS_VER(i915) == 6 &&
> > +	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> > +		return -ENODEV;
> > +
> > +	query.cs_frequency = engine->gt->clock_frequency;
> > +	ret = __query_cs_cycles(engine,
> > +				&query.cs_cycles,
> > +				query.cpu_timestamp,
> > +				cpu_clock);
> > +	if (ret)
> > +		return ret;
> > +
> > +	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> > +		return -EFAULT;
> > +
> > +	if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
> > +		return -EFAULT;
> > +
> > +	if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
> > +		return -EFAULT;
> > +
> > +	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> > +		return -EFAULT;
> > +
> > +	return sizeof(query);
> > +}
> > +
> >  static int
> >  query_engine_info(struct drm_i915_private *i915,
> >  		  struct drm_i915_query_item *query_item)
> > @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
> >  	query_topology_info,
> >  	query_engine_info,
> >  	query_perf_config,
> > +	query_cs_cycles,
> >  };
> >  
> >  int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> > diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> > index 6a34243a7646..08b00f1709b5 100644
> > --- a/include/uapi/drm/i915_drm.h
> > +++ b/include/uapi/drm/i915_drm.h
> > @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
> >  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
> >  #define DRM_I915_QUERY_ENGINE_INFO	2
> >  #define DRM_I915_QUERY_PERF_CONFIG      3
> > +	/**
> > +	 * Query Command Streamer timestamp register.
> > +	 */
> > +#define DRM_I915_QUERY_CS_CYCLES	4
> >  /* Must be kept compact -- no holes and well documented */
> >  
> >  	/**
> > @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
> >  	__u64 rsvd1[4];
> >  };
> >  
> > +/**
> > + * struct drm_i915_query_cs_cycles
> > + *
> > + * The query returns the command streamer cycles and the frequency that can be
> > + * used to calculate the command streamer timestamp. In addition the query
> > + * returns a set of cpu timestamps that indicate when the command streamer cycle
> > + * count was captured.
> > + */
> > +struct drm_i915_query_cs_cycles {
> > +	/** Engine for which command streamer cycles is queried. */
> > +	struct i915_engine_class_instance engine;
> > +
> > +	/** Must be zero. */
> > +	__u32 flags;
> > +
> > +	/**
> > +	 * Command streamer cycles as read from the command streamer
> > +	 * register at 0x358 offset.
> > +	 */
> > +	__u64 cs_cycles;
> > +
> > +	/** Frequency of the cs cycles in Hz. */
> > +	__u64 cs_frequency;
> > +
> > +	/**
> > +	 * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
> > +	 * cs_cycles register using the reference clockid set by the user.
> > +	 * cpu_timestamp[1] is the time taken in ns to read the lower dword of
> > +	 * the cs_cycles register.
> > +	 */
> > +	__u64 cpu_timestamp[2];
> > +
> > +	/**
> > +	 * Reference clock id for CPU timestamp. For definition, see
> > +	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> > +	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> > +	 * CLOCK_TAI.
> > +	 */
> > +	__s32 clockid;
> > +
> > +	/** Must be zero. */
> > +	__u32 rsvd;
> > +};
> > +
> >  /**
> >   * struct drm_i915_query_engine_info
> >   *
> 
> -- 
> Jani Nikula, Intel Open Source Graphics Center

-- 
Daniel Vetter
Software Engineer, Intel Corporation
http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 0/1] Add support for querying engine cycles

[Umesh Nerlige Ramappa]

This is just a refresh of the earlier patch along with cover letter for the IGT
testing. The query provides the engine cs cycles counter.

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
Test-with: 20210421172046.65062-1-umesh.nerlige.ramappa@intel.com

Umesh Nerlige Ramappa (1):
  i915/query: Correlate engine and cpu timestamps with better accuracy

 drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  48 ++++++++++
 2 files changed, 193 insertions(+)

-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

[Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

Perf measurements rely on CPU and engine timestamps to correlate
events of interest across these time domains. Current mechanisms get
these timestamps separately and the calculated delta between these
timestamps lack enough accuracy.

To improve the accuracy of these time measurements to within a few us,
add a query that returns the engine and cpu timestamps captured as
close to each other as possible.

v2: (Tvrtko)
- document clock reference used
- return cpu timestamp always
- capture cpu time just before lower dword of cs timestamp

v3: (Chris)
- use uncore-rpm
- use __query_cs_timestamp helper

v4: (Lionel)
- Kernel perf subsytem allows users to specify the clock id to be used
  in perf_event_open. This clock id is used by the perf subsystem to
  return the appropriate cpu timestamp in perf events. Similarly, let
  the user pass the clockid to this query so that cpu timestamp
  corresponds to the clock id requested.

v5: (Tvrtko)
- Use normal ktime accessors instead of fast versions
- Add more uApi documentation

v6: (Lionel)
- Move switch out of spinlock

v7: (Chris)
- cs_timestamp is a misnomer, use cs_cycles instead
- return the cs cycle frequency as well in the query

v8:
- Add platform and engine specific checks

v9: (Lionel)
- Return 2 cpu timestamps in the query - captured before and after the
  register read

v10: (Chris)
- Use local_clock() to measure time taken to read lower dword of
  register and return it to user.

Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
---
 drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
 include/uapi/drm/i915_drm.h       |  48 ++++++++++
 2 files changed, 193 insertions(+)

diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
index fed337ad7b68..25b96927ab92 100644
--- a/drivers/gpu/drm/i915/i915_query.c
+++ b/drivers/gpu/drm/i915/i915_query.c
@@ -6,6 +6,8 @@
 
 #include <linux/nospec.h>
 
+#include "gt/intel_engine_pm.h"
+#include "gt/intel_engine_user.h"
 #include "i915_drv.h"
 #include "i915_perf.h"
 #include "i915_query.h"
@@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
 	return total_length;
 }
 
+typedef u64 (*__ktime_func_t)(void);
+static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
+{
+	/*
+	 * Use logic same as the perf subsystem to allow user to select the
+	 * reference clock id to be used for timestamps.
+	 */
+	switch (clk_id) {
+	case CLOCK_MONOTONIC:
+		return &ktime_get_ns;
+	case CLOCK_MONOTONIC_RAW:
+		return &ktime_get_raw_ns;
+	case CLOCK_REALTIME:
+		return &ktime_get_real_ns;
+	case CLOCK_BOOTTIME:
+		return &ktime_get_boottime_ns;
+	case CLOCK_TAI:
+		return &ktime_get_clocktai_ns;
+	default:
+		return NULL;
+	}
+}
+
+static inline int
+__read_timestamps(struct intel_uncore *uncore,
+		  i915_reg_t lower_reg,
+		  i915_reg_t upper_reg,
+		  u64 *cs_ts,
+		  u64 *cpu_ts,
+		  __ktime_func_t cpu_clock)
+{
+	u32 upper, lower, old_upper, loop = 0;
+
+	upper = intel_uncore_read_fw(uncore, upper_reg);
+	do {
+		cpu_ts[1] = local_clock();
+		cpu_ts[0] = cpu_clock();
+		lower = intel_uncore_read_fw(uncore, lower_reg);
+		cpu_ts[1] = local_clock() - cpu_ts[1];
+		old_upper = upper;
+		upper = intel_uncore_read_fw(uncore, upper_reg);
+	} while (upper != old_upper && loop++ < 2);
+
+	*cs_ts = (u64)upper << 32 | lower;
+
+	return 0;
+}
+
+static int
+__query_cs_cycles(struct intel_engine_cs *engine,
+		  u64 *cs_ts, u64 *cpu_ts,
+		  __ktime_func_t cpu_clock)
+{
+	struct intel_uncore *uncore = engine->uncore;
+	enum forcewake_domains fw_domains;
+	u32 base = engine->mmio_base;
+	intel_wakeref_t wakeref;
+	int ret;
+
+	fw_domains = intel_uncore_forcewake_for_reg(uncore,
+						    RING_TIMESTAMP(base),
+						    FW_REG_READ);
+
+	with_intel_runtime_pm(uncore->rpm, wakeref) {
+		spin_lock_irq(&uncore->lock);
+		intel_uncore_forcewake_get__locked(uncore, fw_domains);
+
+		ret = __read_timestamps(uncore,
+					RING_TIMESTAMP(base),
+					RING_TIMESTAMP_UDW(base),
+					cs_ts,
+					cpu_ts,
+					cpu_clock);
+
+		intel_uncore_forcewake_put__locked(uncore, fw_domains);
+		spin_unlock_irq(&uncore->lock);
+	}
+
+	return ret;
+}
+
+static int
+query_cs_cycles(struct drm_i915_private *i915,
+		struct drm_i915_query_item *query_item)
+{
+	struct drm_i915_query_cs_cycles __user *query_ptr;
+	struct drm_i915_query_cs_cycles query;
+	struct intel_engine_cs *engine;
+	__ktime_func_t cpu_clock;
+	int ret;
+
+	if (INTEL_GEN(i915) < 6)
+		return -ENODEV;
+
+	query_ptr = u64_to_user_ptr(query_item->data_ptr);
+	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
+	if (ret != 0)
+		return ret;
+
+	if (query.flags)
+		return -EINVAL;
+
+	if (query.rsvd)
+		return -EINVAL;
+
+	cpu_clock = __clock_id_to_func(query.clockid);
+	if (!cpu_clock)
+		return -EINVAL;
+
+	engine = intel_engine_lookup_user(i915,
+					  query.engine.engine_class,
+					  query.engine.engine_instance);
+	if (!engine)
+		return -EINVAL;
+
+	if (IS_GEN(i915, 6) &&
+	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
+		return -ENODEV;
+
+	query.cs_frequency = engine->gt->clock_frequency;
+	ret = __query_cs_cycles(engine,
+				&query.cs_cycles,
+				query.cpu_timestamp,
+				cpu_clock);
+	if (ret)
+		return ret;
+
+	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
+		return -EFAULT;
+
+	if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
+		return -EFAULT;
+
+	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
+		return -EFAULT;
+
+	return sizeof(query);
+}
+
 static int
 query_engine_info(struct drm_i915_private *i915,
 		  struct drm_i915_query_item *query_item)
@@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
 	query_topology_info,
 	query_engine_info,
 	query_perf_config,
+	query_cs_cycles,
 };
 
 int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
index 6a34243a7646..08b00f1709b5 100644
--- a/include/uapi/drm/i915_drm.h
+++ b/include/uapi/drm/i915_drm.h
@@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
 #define DRM_I915_QUERY_TOPOLOGY_INFO    1
 #define DRM_I915_QUERY_ENGINE_INFO	2
 #define DRM_I915_QUERY_PERF_CONFIG      3
+	/**
+	 * Query Command Streamer timestamp register.
+	 */
+#define DRM_I915_QUERY_CS_CYCLES	4
 /* Must be kept compact -- no holes and well documented */
 
 	/**
@@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
 	__u64 rsvd1[4];
 };
 
+/**
+ * struct drm_i915_query_cs_cycles
+ *
+ * The query returns the command streamer cycles and the frequency that can be
+ * used to calculate the command streamer timestamp. In addition the query
+ * returns a set of cpu timestamps that indicate when the command streamer cycle
+ * count was captured.
+ */
+struct drm_i915_query_cs_cycles {
+	/** Engine for which command streamer cycles is queried. */
+	struct i915_engine_class_instance engine;
+
+	/** Must be zero. */
+	__u32 flags;
+
+	/**
+	 * Command streamer cycles as read from the command streamer
+	 * register at 0x358 offset.
+	 */
+	__u64 cs_cycles;
+
+	/** Frequency of the cs cycles in Hz. */
+	__u64 cs_frequency;
+
+	/**
+	 * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
+	 * cs_cycles register using the reference clockid set by the user.
+	 * cpu_timestamp[1] is the time taken in ns to read the lower dword of
+	 * the cs_cycles register.
+	 */
+	__u64 cpu_timestamp[2];
+
+	/**
+	 * Reference clock id for CPU timestamp. For definition, see
+	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
+	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
+	 * CLOCK_TAI.
+	 */
+	__s32 clockid;
+
+	/** Must be zero. */
+	__u32 rsvd;
+};
+
 /**
  * struct drm_i915_query_engine_info
  *
-- 
2.20.1

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Lionel Landwerlin]

On 21/04/2021 20:28, Umesh Nerlige Ramappa wrote:
> Perf measurements rely on CPU and engine timestamps to correlate
> events of interest across these time domains. Current mechanisms get
> these timestamps separately and the calculated delta between these
> timestamps lack enough accuracy.
>
> To improve the accuracy of these time measurements to within a few us,
> add a query that returns the engine and cpu timestamps captured as
> close to each other as possible.
>
> v2: (Tvrtko)
> - document clock reference used
> - return cpu timestamp always
> - capture cpu time just before lower dword of cs timestamp
>
> v3: (Chris)
> - use uncore-rpm
> - use __query_cs_timestamp helper
>
> v4: (Lionel)
> - Kernel perf subsytem allows users to specify the clock id to be used
>    in perf_event_open. This clock id is used by the perf subsystem to
>    return the appropriate cpu timestamp in perf events. Similarly, let
>    the user pass the clockid to this query so that cpu timestamp
>    corresponds to the clock id requested.
>
> v5: (Tvrtko)
> - Use normal ktime accessors instead of fast versions
> - Add more uApi documentation
>
> v6: (Lionel)
> - Move switch out of spinlock
>
> v7: (Chris)
> - cs_timestamp is a misnomer, use cs_cycles instead
> - return the cs cycle frequency as well in the query
>
> v8:
> - Add platform and engine specific checks
>
> v9: (Lionel)
> - Return 2 cpu timestamps in the query - captured before and after the
>    register read
>
> v10: (Chris)
> - Use local_clock() to measure time taken to read lower dword of
>    register and return it to user.
>
> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
> ---
>   drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>   include/uapi/drm/i915_drm.h       |  48 ++++++++++
>   2 files changed, 193 insertions(+)
>
> diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
> index fed337ad7b68..25b96927ab92 100644
> --- a/drivers/gpu/drm/i915/i915_query.c
> +++ b/drivers/gpu/drm/i915/i915_query.c
> @@ -6,6 +6,8 @@
>   
>   #include <linux/nospec.h>
>   
> +#include "gt/intel_engine_pm.h"
> +#include "gt/intel_engine_user.h"
>   #include "i915_drv.h"
>   #include "i915_perf.h"
>   #include "i915_query.h"
> @@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>   	return total_length;
>   }
>   
> +typedef u64 (*__ktime_func_t)(void);
> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
> +{
> +	/*
> +	 * Use logic same as the perf subsystem to allow user to select the
> +	 * reference clock id to be used for timestamps.
> +	 */
> +	switch (clk_id) {
> +	case CLOCK_MONOTONIC:
> +		return &ktime_get_ns;
> +	case CLOCK_MONOTONIC_RAW:
> +		return &ktime_get_raw_ns;
> +	case CLOCK_REALTIME:
> +		return &ktime_get_real_ns;
> +	case CLOCK_BOOTTIME:
> +		return &ktime_get_boottime_ns;
> +	case CLOCK_TAI:
> +		return &ktime_get_clocktai_ns;
> +	default:
> +		return NULL;
> +	}
> +}
> +
> +static inline int
> +__read_timestamps(struct intel_uncore *uncore,
> +		  i915_reg_t lower_reg,
> +		  i915_reg_t upper_reg,
> +		  u64 *cs_ts,
> +		  u64 *cpu_ts,
> +		  __ktime_func_t cpu_clock)
> +{
> +	u32 upper, lower, old_upper, loop = 0;
> +
> +	upper = intel_uncore_read_fw(uncore, upper_reg);
> +	do {
> +		cpu_ts[1] = local_clock();
> +		cpu_ts[0] = cpu_clock();
> +		lower = intel_uncore_read_fw(uncore, lower_reg);
> +		cpu_ts[1] = local_clock() - cpu_ts[1];
> +		old_upper = upper;
> +		upper = intel_uncore_read_fw(uncore, upper_reg);
> +	} while (upper != old_upper && loop++ < 2);
> +
> +	*cs_ts = (u64)upper << 32 | lower;
> +
> +	return 0;
> +}
> +
> +static int
> +__query_cs_cycles(struct intel_engine_cs *engine,
> +		  u64 *cs_ts, u64 *cpu_ts,
> +		  __ktime_func_t cpu_clock)
> +{
> +	struct intel_uncore *uncore = engine->uncore;
> +	enum forcewake_domains fw_domains;
> +	u32 base = engine->mmio_base;
> +	intel_wakeref_t wakeref;
> +	int ret;
> +
> +	fw_domains = intel_uncore_forcewake_for_reg(uncore,
> +						    RING_TIMESTAMP(base),
> +						    FW_REG_READ);
> +
> +	with_intel_runtime_pm(uncore->rpm, wakeref) {
> +		spin_lock_irq(&uncore->lock);
> +		intel_uncore_forcewake_get__locked(uncore, fw_domains);
> +
> +		ret = __read_timestamps(uncore,
> +					RING_TIMESTAMP(base),
> +					RING_TIMESTAMP_UDW(base),
> +					cs_ts,
> +					cpu_ts,
> +					cpu_clock);
> +
> +		intel_uncore_forcewake_put__locked(uncore, fw_domains);
> +		spin_unlock_irq(&uncore->lock);
> +	}
> +
> +	return ret;
> +}
> +
> +static int
> +query_cs_cycles(struct drm_i915_private *i915,
> +		struct drm_i915_query_item *query_item)
> +{
> +	struct drm_i915_query_cs_cycles __user *query_ptr;
> +	struct drm_i915_query_cs_cycles query;
> +	struct intel_engine_cs *engine;
> +	__ktime_func_t cpu_clock;
> +	int ret;
> +
> +	if (INTEL_GEN(i915) < 6)
> +		return -ENODEV;
> +
> +	query_ptr = u64_to_user_ptr(query_item->data_ptr);
> +	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
> +	if (ret != 0)
> +		return ret;
> +
> +	if (query.flags)
> +		return -EINVAL;
> +
> +	if (query.rsvd)
> +		return -EINVAL;
> +
> +	cpu_clock = __clock_id_to_func(query.clockid);
> +	if (!cpu_clock)
> +		return -EINVAL;
> +
> +	engine = intel_engine_lookup_user(i915,
> +					  query.engine.engine_class,
> +					  query.engine.engine_instance);
> +	if (!engine)
> +		return -EINVAL;
> +
> +	if (IS_GEN(i915, 6) &&
> +	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
> +		return -ENODEV;


Thanks a bunch for rebasing this.

My only comment on this patch would be : don't we want 
IS_GEN_RANGE(i915, 1, 6) instead of IS_GEN(i915, 6) ?

(assuming gen1 is a thing...)


-Lionel


> +
> +	query.cs_frequency = engine->gt->clock_frequency;
> +	ret = __query_cs_cycles(engine,
> +				&query.cs_cycles,
> +				query.cpu_timestamp,
> +				cpu_clock);
> +	if (ret)
> +		return ret;
> +
> +	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
> +		return -EFAULT;
> +
> +	if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
> +		return -EFAULT;
> +
> +	if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
> +		return -EFAULT;
> +
> +	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
> +		return -EFAULT;
> +
> +	return sizeof(query);
> +}
> +
>   static int
>   query_engine_info(struct drm_i915_private *i915,
>   		  struct drm_i915_query_item *query_item)
> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>   	query_topology_info,
>   	query_engine_info,
>   	query_perf_config,
> +	query_cs_cycles,
>   };
>   
>   int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
> index 6a34243a7646..08b00f1709b5 100644
> --- a/include/uapi/drm/i915_drm.h
> +++ b/include/uapi/drm/i915_drm.h
> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>   #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>   #define DRM_I915_QUERY_ENGINE_INFO	2
>   #define DRM_I915_QUERY_PERF_CONFIG      3
> +	/**
> +	 * Query Command Streamer timestamp register.
> +	 */
> +#define DRM_I915_QUERY_CS_CYCLES	4
>   /* Must be kept compact -- no holes and well documented */
>   
>   	/**
> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>   	__u64 rsvd1[4];
>   };
>   
> +/**
> + * struct drm_i915_query_cs_cycles
> + *
> + * The query returns the command streamer cycles and the frequency that can be
> + * used to calculate the command streamer timestamp. In addition the query
> + * returns a set of cpu timestamps that indicate when the command streamer cycle
> + * count was captured.
> + */
> +struct drm_i915_query_cs_cycles {
> +	/** Engine for which command streamer cycles is queried. */
> +	struct i915_engine_class_instance engine;
> +
> +	/** Must be zero. */
> +	__u32 flags;
> +
> +	/**
> +	 * Command streamer cycles as read from the command streamer
> +	 * register at 0x358 offset.
> +	 */
> +	__u64 cs_cycles;
> +
> +	/** Frequency of the cs cycles in Hz. */
> +	__u64 cs_frequency;
> +
> +	/**
> +	 * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
> +	 * cs_cycles register using the reference clockid set by the user.
> +	 * cpu_timestamp[1] is the time taken in ns to read the lower dword of
> +	 * the cs_cycles register.
> +	 */
> +	__u64 cpu_timestamp[2];
> +
> +	/**
> +	 * Reference clock id for CPU timestamp. For definition, see
> +	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
> +	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
> +	 * CLOCK_TAI.
> +	 */
> +	__s32 clockid;
> +
> +	/** Must be zero. */
> +	__u32 rsvd;
> +};
> +
>   /**
>    * struct drm_i915_query_engine_info
>    *


_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Umesh Nerlige Ramappa]

On Fri, Apr 23, 2021 at 10:05:34AM +0300, Lionel Landwerlin wrote:
>On 21/04/2021 20:28, Umesh Nerlige Ramappa wrote:
>>Perf measurements rely on CPU and engine timestamps to correlate
>>events of interest across these time domains. Current mechanisms get
>>these timestamps separately and the calculated delta between these
>>timestamps lack enough accuracy.
>>
>>To improve the accuracy of these time measurements to within a few us,
>>add a query that returns the engine and cpu timestamps captured as
>>close to each other as possible.
>>
>>v2: (Tvrtko)
>>- document clock reference used
>>- return cpu timestamp always
>>- capture cpu time just before lower dword of cs timestamp
>>
>>v3: (Chris)
>>- use uncore-rpm
>>- use __query_cs_timestamp helper
>>
>>v4: (Lionel)
>>- Kernel perf subsytem allows users to specify the clock id to be used
>>   in perf_event_open. This clock id is used by the perf subsystem to
>>   return the appropriate cpu timestamp in perf events. Similarly, let
>>   the user pass the clockid to this query so that cpu timestamp
>>   corresponds to the clock id requested.
>>
>>v5: (Tvrtko)
>>- Use normal ktime accessors instead of fast versions
>>- Add more uApi documentation
>>
>>v6: (Lionel)
>>- Move switch out of spinlock
>>
>>v7: (Chris)
>>- cs_timestamp is a misnomer, use cs_cycles instead
>>- return the cs cycle frequency as well in the query
>>
>>v8:
>>- Add platform and engine specific checks
>>
>>v9: (Lionel)
>>- Return 2 cpu timestamps in the query - captured before and after the
>>   register read
>>
>>v10: (Chris)
>>- Use local_clock() to measure time taken to read lower dword of
>>   register and return it to user.
>>
>>Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
>>---
>>  drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>>  include/uapi/drm/i915_drm.h       |  48 ++++++++++
>>  2 files changed, 193 insertions(+)
>>
>>diff --git a/drivers/gpu/drm/i915/i915_query.c b/drivers/gpu/drm/i915/i915_query.c
>>index fed337ad7b68..25b96927ab92 100644
>>--- a/drivers/gpu/drm/i915/i915_query.c
>>+++ b/drivers/gpu/drm/i915/i915_query.c
>>@@ -6,6 +6,8 @@
>>  #include <linux/nospec.h>
>>+#include "gt/intel_engine_pm.h"
>>+#include "gt/intel_engine_user.h"
>>  #include "i915_drv.h"
>>  #include "i915_perf.h"
>>  #include "i915_query.h"
>>@@ -90,6 +92,148 @@ static int query_topology_info(struct drm_i915_private *dev_priv,
>>  	return total_length;
>>  }
>>+typedef u64 (*__ktime_func_t)(void);
>>+static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
>>+{
>>+	/*
>>+	 * Use logic same as the perf subsystem to allow user to select the
>>+	 * reference clock id to be used for timestamps.
>>+	 */
>>+	switch (clk_id) {
>>+	case CLOCK_MONOTONIC:
>>+		return &ktime_get_ns;
>>+	case CLOCK_MONOTONIC_RAW:
>>+		return &ktime_get_raw_ns;
>>+	case CLOCK_REALTIME:
>>+		return &ktime_get_real_ns;
>>+	case CLOCK_BOOTTIME:
>>+		return &ktime_get_boottime_ns;
>>+	case CLOCK_TAI:
>>+		return &ktime_get_clocktai_ns;
>>+	default:
>>+		return NULL;
>>+	}
>>+}
>>+
>>+static inline int
>>+__read_timestamps(struct intel_uncore *uncore,
>>+		  i915_reg_t lower_reg,
>>+		  i915_reg_t upper_reg,
>>+		  u64 *cs_ts,
>>+		  u64 *cpu_ts,
>>+		  __ktime_func_t cpu_clock)
>>+{
>>+	u32 upper, lower, old_upper, loop = 0;
>>+
>>+	upper = intel_uncore_read_fw(uncore, upper_reg);
>>+	do {
>>+		cpu_ts[1] = local_clock();
>>+		cpu_ts[0] = cpu_clock();
>>+		lower = intel_uncore_read_fw(uncore, lower_reg);
>>+		cpu_ts[1] = local_clock() - cpu_ts[1];
>>+		old_upper = upper;
>>+		upper = intel_uncore_read_fw(uncore, upper_reg);
>>+	} while (upper != old_upper && loop++ < 2);
>>+
>>+	*cs_ts = (u64)upper << 32 | lower;
>>+
>>+	return 0;
>>+}
>>+
>>+static int
>>+__query_cs_cycles(struct intel_engine_cs *engine,
>>+		  u64 *cs_ts, u64 *cpu_ts,
>>+		  __ktime_func_t cpu_clock)
>>+{
>>+	struct intel_uncore *uncore = engine->uncore;
>>+	enum forcewake_domains fw_domains;
>>+	u32 base = engine->mmio_base;
>>+	intel_wakeref_t wakeref;
>>+	int ret;
>>+
>>+	fw_domains = intel_uncore_forcewake_for_reg(uncore,
>>+						    RING_TIMESTAMP(base),
>>+						    FW_REG_READ);
>>+
>>+	with_intel_runtime_pm(uncore->rpm, wakeref) {
>>+		spin_lock_irq(&uncore->lock);
>>+		intel_uncore_forcewake_get__locked(uncore, fw_domains);
>>+
>>+		ret = __read_timestamps(uncore,
>>+					RING_TIMESTAMP(base),
>>+					RING_TIMESTAMP_UDW(base),
>>+					cs_ts,
>>+					cpu_ts,
>>+					cpu_clock);
>>+
>>+		intel_uncore_forcewake_put__locked(uncore, fw_domains);
>>+		spin_unlock_irq(&uncore->lock);
>>+	}
>>+
>>+	return ret;
>>+}
>>+
>>+static int
>>+query_cs_cycles(struct drm_i915_private *i915,
>>+		struct drm_i915_query_item *query_item)
>>+{
>>+	struct drm_i915_query_cs_cycles __user *query_ptr;
>>+	struct drm_i915_query_cs_cycles query;
>>+	struct intel_engine_cs *engine;
>>+	__ktime_func_t cpu_clock;
>>+	int ret;
>>+
>>+	if (INTEL_GEN(i915) < 6)
>>+		return -ENODEV;

Less than gen6 is handled here early on.

>>+
>>+	query_ptr = u64_to_user_ptr(query_item->data_ptr);
>>+	ret = copy_query_item(&query, sizeof(query), sizeof(query), query_item);
>>+	if (ret != 0)
>>+		return ret;
>>+
>>+	if (query.flags)
>>+		return -EINVAL;
>>+
>>+	if (query.rsvd)
>>+		return -EINVAL;
>>+
>>+	cpu_clock = __clock_id_to_func(query.clockid);
>>+	if (!cpu_clock)
>>+		return -EINVAL;
>>+
>>+	engine = intel_engine_lookup_user(i915,
>>+					  query.engine.engine_class,
>>+					  query.engine.engine_instance);
>>+	if (!engine)
>>+		return -EINVAL;
>>+
>>+	if (IS_GEN(i915, 6) &&
>>+	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>>+		return -ENODEV;
>
>
>Thanks a bunch for rebasing this.
>
>My only comment on this patch would be : don't we want 
>IS_GEN_RANGE(i915, 1, 6) instead of IS_GEN(i915, 6) ?
>
>(assuming gen1 is a thing...)

Less than gen6 check is above at function entry. On gen6, only render 
works, so I wait until I can get the engine to check that.

Thanks,
Umesh

>
>
>-Lionel
>
>
>>+
>>+	query.cs_frequency = engine->gt->clock_frequency;
>>+	ret = __query_cs_cycles(engine,
>>+				&query.cs_cycles,
>>+				query.cpu_timestamp,
>>+				cpu_clock);
>>+	if (ret)
>>+		return ret;
>>+
>>+	if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
>>+		return -EFAULT;
>>+
>>+	if (put_user(query.cpu_timestamp[0], &query_ptr->cpu_timestamp[0]))
>>+		return -EFAULT;
>>+
>>+	if (put_user(query.cpu_timestamp[1], &query_ptr->cpu_timestamp[1]))
>>+		return -EFAULT;
>>+
>>+	if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
>>+		return -EFAULT;
>>+
>>+	return sizeof(query);
>>+}
>>+
>>  static int
>>  query_engine_info(struct drm_i915_private *i915,
>>  		  struct drm_i915_query_item *query_item)
>>@@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct drm_i915_private *dev_priv,
>>  	query_topology_info,
>>  	query_engine_info,
>>  	query_perf_config,
>>+	query_cs_cycles,
>>  };
>>  int i915_query_ioctl(struct drm_device *dev, void *data, struct drm_file *file)
>>diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
>>index 6a34243a7646..08b00f1709b5 100644
>>--- a/include/uapi/drm/i915_drm.h
>>+++ b/include/uapi/drm/i915_drm.h
>>@@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>>  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>>  #define DRM_I915_QUERY_ENGINE_INFO	2
>>  #define DRM_I915_QUERY_PERF_CONFIG      3
>>+	/**
>>+	 * Query Command Streamer timestamp register.
>>+	 */
>>+#define DRM_I915_QUERY_CS_CYCLES	4
>>  /* Must be kept compact -- no holes and well documented */
>>  	/**
>>@@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>>  	__u64 rsvd1[4];
>>  };
>>+/**
>>+ * struct drm_i915_query_cs_cycles
>>+ *
>>+ * The query returns the command streamer cycles and the frequency that can be
>>+ * used to calculate the command streamer timestamp. In addition the query
>>+ * returns a set of cpu timestamps that indicate when the command streamer cycle
>>+ * count was captured.
>>+ */
>>+struct drm_i915_query_cs_cycles {
>>+	/** Engine for which command streamer cycles is queried. */
>>+	struct i915_engine_class_instance engine;
>>+
>>+	/** Must be zero. */
>>+	__u32 flags;
>>+
>>+	/**
>>+	 * Command streamer cycles as read from the command streamer
>>+	 * register at 0x358 offset.
>>+	 */
>>+	__u64 cs_cycles;
>>+
>>+	/** Frequency of the cs cycles in Hz. */
>>+	__u64 cs_frequency;
>>+
>>+	/**
>>+	 * CPU timestamps in ns. cpu_timestamp[0] is captured before reading the
>>+	 * cs_cycles register using the reference clockid set by the user.
>>+	 * cpu_timestamp[1] is the time taken in ns to read the lower dword of
>>+	 * the cs_cycles register.
>>+	 */
>>+	__u64 cpu_timestamp[2];
>>+
>>+	/**
>>+	 * Reference clock id for CPU timestamp. For definition, see
>>+	 * clock_gettime(2) and perf_event_open(2). Supported clock ids are
>>+	 * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, CLOCK_BOOTTIME,
>>+	 * CLOCK_TAI.
>>+	 */
>>+	__s32 clockid;
>>+
>>+	/** Must be zero. */
>>+	__u32 rsvd;
>>+};
>>+
>>  /**
>>   * struct drm_i915_query_engine_info
>>   *
>
>
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Lionel Landwerlin]

On 23/04/2021 18:11, Umesh Nerlige Ramappa wrote:
> On Fri, Apr 23, 2021 at 10:05:34AM +0300, Lionel Landwerlin wrote:
>> On 21/04/2021 20:28, Umesh Nerlige Ramappa wrote:
>>> Perf measurements rely on CPU and engine timestamps to correlate
>>> events of interest across these time domains. Current mechanisms get
>>> these timestamps separately and the calculated delta between these
>>> timestamps lack enough accuracy.
>>>
>>> To improve the accuracy of these time measurements to within a few us,
>>> add a query that returns the engine and cpu timestamps captured as
>>> close to each other as possible.
>>>
>>> v2: (Tvrtko)
>>> - document clock reference used
>>> - return cpu timestamp always
>>> - capture cpu time just before lower dword of cs timestamp
>>>
>>> v3: (Chris)
>>> - use uncore-rpm
>>> - use __query_cs_timestamp helper
>>>
>>> v4: (Lionel)
>>> - Kernel perf subsytem allows users to specify the clock id to be used
>>>   in perf_event_open. This clock id is used by the perf subsystem to
>>>   return the appropriate cpu timestamp in perf events. Similarly, let
>>>   the user pass the clockid to this query so that cpu timestamp
>>>   corresponds to the clock id requested.
>>>
>>> v5: (Tvrtko)
>>> - Use normal ktime accessors instead of fast versions
>>> - Add more uApi documentation
>>>
>>> v6: (Lionel)
>>> - Move switch out of spinlock
>>>
>>> v7: (Chris)
>>> - cs_timestamp is a misnomer, use cs_cycles instead
>>> - return the cs cycle frequency as well in the query
>>>
>>> v8:
>>> - Add platform and engine specific checks
>>>
>>> v9: (Lionel)
>>> - Return 2 cpu timestamps in the query - captured before and after the
>>>   register read
>>>
>>> v10: (Chris)
>>> - Use local_clock() to measure time taken to read lower dword of
>>>   register and return it to user.
>>>
>>> Signed-off-by: Umesh Nerlige Ramappa <umesh.nerlige.ramappa@intel.com>
>>> ---
>>>  drivers/gpu/drm/i915/i915_query.c | 145 ++++++++++++++++++++++++++++++
>>>  include/uapi/drm/i915_drm.h       |  48 ++++++++++
>>>  2 files changed, 193 insertions(+)
>>>
>>> diff --git a/drivers/gpu/drm/i915/i915_query.c 
>>> b/drivers/gpu/drm/i915/i915_query.c
>>> index fed337ad7b68..25b96927ab92 100644
>>> --- a/drivers/gpu/drm/i915/i915_query.c
>>> +++ b/drivers/gpu/drm/i915/i915_query.c
>>> @@ -6,6 +6,8 @@
>>>  #include <linux/nospec.h>
>>> +#include "gt/intel_engine_pm.h"
>>> +#include "gt/intel_engine_user.h"
>>>  #include "i915_drv.h"
>>>  #include "i915_perf.h"
>>>  #include "i915_query.h"
>>> @@ -90,6 +92,148 @@ static int query_topology_info(struct 
>>> drm_i915_private *dev_priv,
>>>      return total_length;
>>>  }
>>> +typedef u64 (*__ktime_func_t)(void);
>>> +static __ktime_func_t __clock_id_to_func(clockid_t clk_id)
>>> +{
>>> +    /*
>>> +     * Use logic same as the perf subsystem to allow user to select 
>>> the
>>> +     * reference clock id to be used for timestamps.
>>> +     */
>>> +    switch (clk_id) {
>>> +    case CLOCK_MONOTONIC:
>>> +        return &ktime_get_ns;
>>> +    case CLOCK_MONOTONIC_RAW:
>>> +        return &ktime_get_raw_ns;
>>> +    case CLOCK_REALTIME:
>>> +        return &ktime_get_real_ns;
>>> +    case CLOCK_BOOTTIME:
>>> +        return &ktime_get_boottime_ns;
>>> +    case CLOCK_TAI:
>>> +        return &ktime_get_clocktai_ns;
>>> +    default:
>>> +        return NULL;
>>> +    }
>>> +}
>>> +
>>> +static inline int
>>> +__read_timestamps(struct intel_uncore *uncore,
>>> +          i915_reg_t lower_reg,
>>> +          i915_reg_t upper_reg,
>>> +          u64 *cs_ts,
>>> +          u64 *cpu_ts,
>>> +          __ktime_func_t cpu_clock)
>>> +{
>>> +    u32 upper, lower, old_upper, loop = 0;
>>> +
>>> +    upper = intel_uncore_read_fw(uncore, upper_reg);
>>> +    do {
>>> +        cpu_ts[1] = local_clock();
>>> +        cpu_ts[0] = cpu_clock();
>>> +        lower = intel_uncore_read_fw(uncore, lower_reg);
>>> +        cpu_ts[1] = local_clock() - cpu_ts[1];
>>> +        old_upper = upper;
>>> +        upper = intel_uncore_read_fw(uncore, upper_reg);
>>> +    } while (upper != old_upper && loop++ < 2);
>>> +
>>> +    *cs_ts = (u64)upper << 32 | lower;
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +static int
>>> +__query_cs_cycles(struct intel_engine_cs *engine,
>>> +          u64 *cs_ts, u64 *cpu_ts,
>>> +          __ktime_func_t cpu_clock)
>>> +{
>>> +    struct intel_uncore *uncore = engine->uncore;
>>> +    enum forcewake_domains fw_domains;
>>> +    u32 base = engine->mmio_base;
>>> +    intel_wakeref_t wakeref;
>>> +    int ret;
>>> +
>>> +    fw_domains = intel_uncore_forcewake_for_reg(uncore,
>>> +                            RING_TIMESTAMP(base),
>>> +                            FW_REG_READ);
>>> +
>>> +    with_intel_runtime_pm(uncore->rpm, wakeref) {
>>> +        spin_lock_irq(&uncore->lock);
>>> +        intel_uncore_forcewake_get__locked(uncore, fw_domains);
>>> +
>>> +        ret = __read_timestamps(uncore,
>>> +                    RING_TIMESTAMP(base),
>>> +                    RING_TIMESTAMP_UDW(base),
>>> +                    cs_ts,
>>> +                    cpu_ts,
>>> +                    cpu_clock);
>>> +
>>> +        intel_uncore_forcewake_put__locked(uncore, fw_domains);
>>> +        spin_unlock_irq(&uncore->lock);
>>> +    }
>>> +
>>> +    return ret;
>>> +}
>>> +
>>> +static int
>>> +query_cs_cycles(struct drm_i915_private *i915,
>>> +        struct drm_i915_query_item *query_item)
>>> +{
>>> +    struct drm_i915_query_cs_cycles __user *query_ptr;
>>> +    struct drm_i915_query_cs_cycles query;
>>> +    struct intel_engine_cs *engine;
>>> +    __ktime_func_t cpu_clock;
>>> +    int ret;
>>> +
>>> +    if (INTEL_GEN(i915) < 6)
>>> +        return -ENODEV;
>
> Less than gen6 is handled here early on.
>
>>> +
>>> +    query_ptr = u64_to_user_ptr(query_item->data_ptr);
>>> +    ret = copy_query_item(&query, sizeof(query), sizeof(query), 
>>> query_item);
>>> +    if (ret != 0)
>>> +        return ret;
>>> +
>>> +    if (query.flags)
>>> +        return -EINVAL;
>>> +
>>> +    if (query.rsvd)
>>> +        return -EINVAL;
>>> +
>>> +    cpu_clock = __clock_id_to_func(query.clockid);
>>> +    if (!cpu_clock)
>>> +        return -EINVAL;
>>> +
>>> +    engine = intel_engine_lookup_user(i915,
>>> +                      query.engine.engine_class,
>>> +                      query.engine.engine_instance);
>>> +    if (!engine)
>>> +        return -EINVAL;
>>> +
>>> +    if (IS_GEN(i915, 6) &&
>>> +        query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>>> +        return -ENODEV;
>>
>>
>> Thanks a bunch for rebasing this.
>>
>> My only comment on this patch would be : don't we want 
>> IS_GEN_RANGE(i915, 1, 6) instead of IS_GEN(i915, 6) ?
>>
>> (assuming gen1 is a thing...)
>
> Less than gen6 check is above at function entry. On gen6, only render 
> works, so I wait until I can get the engine to check that.


Ah okay, I thought we could go for parity with REG_READ which seems to 
go back to Gen4.

But it's not important at least for mesa because we probably only case 
about gen7+.


Hopefuly nobody else has objections :


Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>


Thanks,


-Lionel


>
> Thanks,
> Umesh
>
>>
>>
>> -Lionel
>>
>>
>>> +
>>> +    query.cs_frequency = engine->gt->clock_frequency;
>>> +    ret = __query_cs_cycles(engine,
>>> +                &query.cs_cycles,
>>> +                query.cpu_timestamp,
>>> +                cpu_clock);
>>> +    if (ret)
>>> +        return ret;
>>> +
>>> +    if (put_user(query.cs_frequency, &query_ptr->cs_frequency))
>>> +        return -EFAULT;
>>> +
>>> +    if (put_user(query.cpu_timestamp[0], 
>>> &query_ptr->cpu_timestamp[0]))
>>> +        return -EFAULT;
>>> +
>>> +    if (put_user(query.cpu_timestamp[1], 
>>> &query_ptr->cpu_timestamp[1]))
>>> +        return -EFAULT;
>>> +
>>> +    if (put_user(query.cs_cycles, &query_ptr->cs_cycles))
>>> +        return -EFAULT;
>>> +
>>> +    return sizeof(query);
>>> +}
>>> +
>>>  static int
>>>  query_engine_info(struct drm_i915_private *i915,
>>>            struct drm_i915_query_item *query_item)
>>> @@ -424,6 +568,7 @@ static int (* const i915_query_funcs[])(struct 
>>> drm_i915_private *dev_priv,
>>>      query_topology_info,
>>>      query_engine_info,
>>>      query_perf_config,
>>> +    query_cs_cycles,
>>>  };
>>>  int i915_query_ioctl(struct drm_device *dev, void *data, struct 
>>> drm_file *file)
>>> diff --git a/include/uapi/drm/i915_drm.h b/include/uapi/drm/i915_drm.h
>>> index 6a34243a7646..08b00f1709b5 100644
>>> --- a/include/uapi/drm/i915_drm.h
>>> +++ b/include/uapi/drm/i915_drm.h
>>> @@ -2230,6 +2230,10 @@ struct drm_i915_query_item {
>>>  #define DRM_I915_QUERY_TOPOLOGY_INFO    1
>>>  #define DRM_I915_QUERY_ENGINE_INFO    2
>>>  #define DRM_I915_QUERY_PERF_CONFIG      3
>>> +    /**
>>> +     * Query Command Streamer timestamp register.
>>> +     */
>>> +#define DRM_I915_QUERY_CS_CYCLES    4
>>>  /* Must be kept compact -- no holes and well documented */
>>>      /**
>>> @@ -2397,6 +2401,50 @@ struct drm_i915_engine_info {
>>>      __u64 rsvd1[4];
>>>  };
>>> +/**
>>> + * struct drm_i915_query_cs_cycles
>>> + *
>>> + * The query returns the command streamer cycles and the frequency 
>>> that can be
>>> + * used to calculate the command streamer timestamp. In addition 
>>> the query
>>> + * returns a set of cpu timestamps that indicate when the command 
>>> streamer cycle
>>> + * count was captured.
>>> + */
>>> +struct drm_i915_query_cs_cycles {
>>> +    /** Engine for which command streamer cycles is queried. */
>>> +    struct i915_engine_class_instance engine;
>>> +
>>> +    /** Must be zero. */
>>> +    __u32 flags;
>>> +
>>> +    /**
>>> +     * Command streamer cycles as read from the command streamer
>>> +     * register at 0x358 offset.
>>> +     */
>>> +    __u64 cs_cycles;
>>> +
>>> +    /** Frequency of the cs cycles in Hz. */
>>> +    __u64 cs_frequency;
>>> +
>>> +    /**
>>> +     * CPU timestamps in ns. cpu_timestamp[0] is captured before 
>>> reading the
>>> +     * cs_cycles register using the reference clockid set by the user.
>>> +     * cpu_timestamp[1] is the time taken in ns to read the lower 
>>> dword of
>>> +     * the cs_cycles register.
>>> +     */
>>> +    __u64 cpu_timestamp[2];
>>> +
>>> +    /**
>>> +     * Reference clock id for CPU timestamp. For definition, see
>>> +     * clock_gettime(2) and perf_event_open(2). Supported clock ids 
>>> are
>>> +     * CLOCK_MONOTONIC, CLOCK_MONOTONIC_RAW, CLOCK_REALTIME, 
>>> CLOCK_BOOTTIME,
>>> +     * CLOCK_TAI.
>>> +     */
>>> +    __s32 clockid;
>>> +
>>> +    /** Must be zero. */
>>> +    __u32 rsvd;
>>> +};
>>> +
>>>  /**
>>>   * struct drm_i915_query_engine_info
>>>   *
>>
>>

_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Re: [Intel-gfx] [PATCH 1/1] i915/query: Correlate engine and cpu timestamps with better accuracy

[Jani Nikula]

On Fri, 23 Apr 2021, Lionel Landwerlin <lionel.g.landwerlin@intel.com> wrote:
> On 21/04/2021 20:28, Umesh Nerlige Ramappa wrote:
>> +static int
>> +query_cs_cycles(struct drm_i915_private *i915,
>> +		struct drm_i915_query_item *query_item)
>> +{
>> +	struct drm_i915_query_cs_cycles __user *query_ptr;
>> +	struct drm_i915_query_cs_cycles query;
>> +	struct intel_engine_cs *engine;
>> +	__ktime_func_t cpu_clock;
>> +	int ret;
>> +
>> +	if (INTEL_GEN(i915) < 6)
>> +		return -ENODEV;
>> +

[...]

>> +
>> +	if (IS_GEN(i915, 6) &&
>> +	    query.engine.engine_class != I915_ENGINE_CLASS_RENDER)
>> +		return -ENODEV;
>
>
> Thanks a bunch for rebasing this.
>
> My only comment on this patch would be : don't we want 
> IS_GEN_RANGE(i915, 1, 6) instead of IS_GEN(i915, 6) ?

Please see the new deprecation comments in i915_drv.h. We're moving from
GEN to VER. In short, please use the new VER macros for individual
components instead of the generic GEN.

Thanks,
Jani.


-- 
Jani Nikula, Intel Open Source Graphics Center
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/intel-gfx