performance measurements: global perf meas backend

Implement global performance measurement which measure performance of .copy
functions of multiple components.

Signed-off-by: Tobiasz Dryjanski <tobiaszx.dryjanski@intel.com>

Author: tobonex

src/audio/base_fw.c

@@ -23,6 +23,7 @@
 #include <sof/schedule/dp_schedule.h>
 #include <sof/schedule/ll_schedule.h>
 #include <sof/debug/telemetry/telemetry.h>
+#include <sof/debug/telemetry/performance_monitor.h>
 /* FIXME:
  * Builds for some platforms like tgl fail because their defines related to memory windows are
  * already defined somewhere else. Remove this ifdef after it's cleaned up

src/audio/component.c

@@ -6,6 +6,7 @@
 
 #include <sof/audio/component_ext.h>
 #include <sof/common.h>
+#include <sof/debug/telemetry/performance_monitor.h>
 #include <rtos/panic.h>
 #include <rtos/interrupt.h>
 #include <sof/ipc/msg.h>
@@ -493,8 +494,18 @@ int comp_copy(struct comp_dev *dev)
 		perf_cnt_init(&dev->pcd);
 #endif
 
+#ifdef CONFIG_SOF_TELEMETRY_PERFORMANCE_MEASUREMENTS
+		const uint32_t begin_stamp = (uint32_t)sof_cycle_get_64();
+#endif
+
 		ret = dev->drv->ops.copy(dev);
 
+#ifdef CONFIG_SOF_TELEMETRY_PERFORMANCE_MEASUREMENTS
+		const uint32_t cycles_consumed = (uint32_t)sof_cycle_get_64() - begin_stamp;
+
+		comp_update_performance_data(dev, cycles_consumed);
+#endif
+
 #if CONFIG_PERFORMANCE_COUNTERS
 		perf_cnt_stamp(&dev->pcd, perf_trace_null, dev);
 		perf_cnt_average(&dev->pcd, comp_perf_avg_info, dev);
@@ -504,6 +515,56 @@ int comp_copy(struct comp_dev *dev)
 	return ret;
 }
 
+#ifdef CONFIG_SOF_TELEMETRY_PERFORMANCE_MEASUREMENTS
+void comp_init_performance_data(struct comp_dev *dev)
+{
+	struct perf_data_item_comp *item = dev->perf_data.perf_data_item;
+
+	if (item)
+		perf_data_item_comp_init(item, dev->ipc_config.id, 0);
+}
+
+/* returns true if budget violation occurred */
+static bool update_peak_of_measured_cpc(struct comp_dev *dev, size_t measured_cpc)
+{
+	if (measured_cpc <= dev->perf_data.peak_of_measured_cpc)
+		return false;
+	dev->perf_data.peak_of_measured_cpc = measured_cpc;
+	return measured_cpc > dev->cpc;
+}
+
+bool comp_update_performance_data(struct comp_dev *dev, uint32_t cycles_used)
+{
+	struct perf_data_item_comp *item = dev->perf_data.perf_data_item;
+
+	if (perf_meas_get_state() == IPC4_PERF_MEASUREMENTS_STARTED) {
+		/* we divide by ibs so we need to check if its set */
+		if (item && dev->ibs != 0) {
+			item->total_iteration_count++;
+			if (item->total_iteration_count == 0) {
+				/* We can't allow count to overflow to 0. Overflow will also make
+				 * some of the results incorrect. We don't want to crash in this
+				 * case, so we just log it. We also reset cycles counter to make
+				 * avg correct again.
+				 */
+				item->total_iteration_count = 1;
+				item->total_cycles_consumed = 0;
+				tr_err(&ipc_tr,
+				       "overflow for module %#x, performance measurement incorrect",
+				       dev_comp_id(dev));
+			}
+			item->total_cycles_consumed += cycles_used;
+			item->item.avg_kcps = item->total_cycles_consumed * dev->ll_chunk_size
+				/ (dev->ibs * item->total_iteration_count);
+			item->item.peak_kcps =
+				MAX(item->item.peak_kcps, (cycles_used * dev->ll_chunk_size)
+				/ dev->ibs);
+		}
+	}
+	return update_peak_of_measured_cpc(dev, cycles_used);
+}
+#endif
+
 #if CONFIG_IPC_MAJOR_4
 static uint32_t get_sample_group_size_in_bytes(const struct ipc4_audio_format fmt)
 {

src/debug/telemetry/performance_monitor.c

@@ -4,14 +4,40 @@
 //
 // Author: Tobiasz Dryjanski <tobiaszx.dryjanski@intel.com>
 
+#include <sof/debug/telemetry/performance_monitor.h>
 #include <zephyr/sys/bitarray.h>
 
+#include <errno.h>
+#include <limits.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <adsp_debug_window.h>
+
+#include <ipc4/base_fw.h>
+
+#define PERFORMANCE_DATA_ENTRIES_COUNT \
+	(CONFIG_MEMORY_WIN_3_SIZE / sizeof(struct perf_data_item_comp))
+
+SYS_BITARRAY_DEFINE_STATIC(performance_data_bit_array, PERFORMANCE_DATA_ENTRIES_COUNT);
+
 struct perf_bitmap {
 	sys_bitarray_t *array;
 	uint16_t occupied;
 	size_t size;
 };
 
+struct perf_bitmap performance_data_bitmap;
+
+struct perf_data_item_comp *perf_data;
+
+/* Note that ref. FW used one state per core, all set together to the same state
+ * by one IPC but only for active cores. It may work slightly different in case
+ * where we enable a core while perf meas is started.
+ */
+enum ipc4_perf_measurements_state_set perf_measurements_state = IPC4_PERF_MEASUREMENTS_DISABLED;
+
 static int perf_bitmap_init(struct perf_bitmap * const bitmap, sys_bitarray_t *array, size_t size)
 {
 	k_spinlock_key_t key = k_spin_lock(&array->lock);
@@ -81,3 +107,96 @@ static bool perf_bitmap_is_bit_clear(struct perf_bitmap * const bitmap, size_t b
 		return false;
 	return !val;
 }
+
+struct perf_data_item_comp *perf_data_getnext(void)
+{
+	int idx;
+	int ret = perf_bitmap_alloc(&performance_data_bitmap, &idx);
+
+	if (ret < 0)
+		return NULL;
+	/* ref. FW did not set the bits, but here we do it to not have to use
+	 * isFree() check that the bitarray does not provide yet. Instead we will use isClear
+	 * ,and always set bit on bitmap alloc.
+	 */
+	ret = perf_bitmap_setbit(&performance_data_bitmap, idx);
+	if (ret < 0)
+		return NULL;
+	return &perf_data[idx];
+}
+
+int perf_data_free(struct perf_data_item_comp * const item)
+{
+	/* find index of item */
+	int idx = (item - perf_data) / sizeof(*item);
+	int ret = perf_bitmap_clearbit(&performance_data_bitmap, idx);
+
+	if (ret < 0)
+		return ret;
+	ret = perf_bitmap_free(&performance_data_bitmap, idx);
+	if (ret < 0)
+		return ret;
+
+	return 0;
+}
+
+void perf_data_item_comp_reset(struct perf_data_item_comp *perf)
+{
+	perf->total_iteration_count = 0;
+	perf->total_cycles_consumed = 0;
+	perf->restricted_total_iterations = 0;
+	perf->restricted_total_cycles = 0;
+	perf->restricted_peak_cycles = 0;
+	perf->item.peak_kcps = 0;
+	perf->item.avg_kcps = 0;
+}
+
+void perf_data_item_comp_init(struct perf_data_item_comp *perf, uint32_t resource_id,
+			      uint32_t power_mode)
+{
+	perf_data_item_comp_reset(perf);
+	perf->item.resource_id = resource_id;
+	perf->item.is_removed = false;
+	perf->item.power_mode = power_mode;
+}
+
+int free_performance_data(struct perf_data_item_comp *item)
+{
+	int ret;
+
+	if (item) {
+		item->item.is_removed = true;
+		/* if we don't get the disabled state now, item will be
+		 * deleted on next disable perf meas message
+		 */
+		if (perf_measurements_state == IPC4_PERF_MEASUREMENTS_DISABLED) {
+			ret = perf_data_free(item);
+			if (ret < 0)
+				return ret;
+		}
+	}
+	return 0;
+}
+
+enum ipc4_perf_measurements_state_set perf_meas_get_state(void)
+{
+	return perf_measurements_state;
+}
+
+void perf_meas_set_state(enum ipc4_perf_measurements_state_set state)
+{
+	perf_measurements_state = state;
+}
+
+int performance_monitor_init(void)
+{
+	/* init global performance measurement */
+	perf_data = (struct perf_data_item_comp *)ADSP_PMW;
+	perf_bitmap_init(&performance_data_bitmap, &performance_data_bit_array,
+			 PERFORMANCE_DATA_ENTRIES_COUNT);
+
+	return 0;
+}
+
+/* init performance monitor using Zephyr */
+SYS_INIT(performance_monitor_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);

src/debug/telemetry/telemetry.c

@@ -10,6 +10,7 @@
 #include <sof/debug/telemetry/telemetry.h>
 
 #include <ipc/trace.h>
+#include <ipc4/base_fw.h>
 
 #include <adsp_debug_window.h>
 #include <errno.h>
@@ -90,6 +91,7 @@ int telemetry_init(void)
 		systick_info[i].peak_utilization_4k = 0;
 		systick_info[i].peak_utilization_8k = 0;
 	}
+
 	return 0;
 }
 

src/include/ipc4/base_fw.h

@@ -731,4 +731,31 @@ struct ipc4_system_time_info *basefw_get_system_time_info(void);
 /* Specifies I2S IPC4 version for PTL platform */
 static const uint32_t I2S_VER_30_PTL       = 0x40000;
 
+struct perf_data_item {
+	/* ID of the FW component */
+	uint32_t resource_id;
+	/* 0 - D0, 1 - D0i3. */
+	uint32_t power_mode : 1;
+	uint32_t rsvd : 30;
+	/* the component still exists (0) or has been already deleted (1) */
+	uint32_t is_removed : 1;
+	/* Peak KCPS captured */
+	uint32_t peak_kcps;
+	/* Average KCPS measured */
+	uint32_t avg_kcps;
+} __packed __aligned(4);
+
+struct perf_data_item_comp {
+	struct perf_data_item item;
+	/* Total iteration count of module instance */
+	uint32_t total_iteration_count;
+	/* Total cycles consumed by module instance */
+	uint64_t total_cycles_consumed;
+	/* <restricted> usage statistics against DSP wallclock cycles */
+	uint32_t restricted_peak_cycles;
+	uint64_t restricted_total_iterations;
+	uint64_t restricted_total_cycles;
+
+} __packed __aligned(4);
+
 #endif /* __SOF_IPC4_BASE_FW_H__ */

src/include/sof/audio/component.h

@@ -19,6 +19,7 @@
 #include <sof/audio/buffer.h>
 #include <sof/audio/format.h>
 #include <sof/audio/pipeline.h>
+#include <sof/debug/telemetry/telemetry.h>
 #include <rtos/idc.h>
 #include <sof/lib/dai.h>
 #include <sof/schedule/schedule.h>
@@ -554,6 +555,18 @@ struct comp_ipc_config {
 #endif
 };
 
+struct comp_perf_data {
+	/* maximum measured cpc on run-time.
+	 *
+	 * if current measured cpc exceeds peak_of_measured_cpc_ then
+	 * ResoruceEvent(BUDGET_VIOLATION) notification must be send.
+	 * Otherwise there is no new information for host to care about
+	 */
+	size_t peak_of_measured_cpc;
+	/* Pointer to performance data structure. */
+	struct perf_data_item_comp *perf_data_item;
+};
+
 /**
  * Audio component base device "class"
  * - used by other component types.
@@ -598,6 +611,8 @@ struct comp_dev {
 	struct list_item bsource_list;	/**< list of source buffers */
 	struct list_item bsink_list;	/**< list of sink buffers */
 
+	/* performance data*/
+	struct comp_perf_data perf_data;
 	/* Input Buffer Size for pin 0, add array for other pins if needed */
 	size_t ibs;
 	/* Output Buffers Size for pin 0, add array for other pins if needed */
@@ -941,4 +956,20 @@ int comp_verify_params(struct comp_dev *dev, uint32_t flag,
  */
 void comp_update_ibs_obs_cpc(struct comp_dev *dev);
 
+/**
+ * If component has assigned slot in performance measurement window,
+ * initialize its fields.
+ * @param dev Component to init.
+ */
+void comp_init_performance_data(struct comp_dev *dev);
+
+/**
+ * Update performance data entry for component. Also checks for budget violation.
+ *
+ * @param dev Component to update.
+ * @param cycles_used Execution time.
+ * @return true if budget violation occurred
+ */
+bool comp_update_performance_data(struct comp_dev *dev, uint32_t cycles_used);
+
 #endif /* __SOF_AUDIO_COMPONENT_H__ */

src/include/sof/debug/telemetry/performance_monitor.h

@@ -8,4 +8,48 @@
 #ifndef __SOF_PERFORMANCE_MONITOR_H__
 #define __SOF_PERFORMANCE_MONITOR_H__
 
+/* to be moved to Zephyr */
+#define WIN3_MBASE DT_REG_ADDR(DT_PHANDLE(DT_NODELABEL(mem_window3), memory))
+#define ADSP_PMW ((volatile uint32_t *) \
+		 (sys_cache_uncached_ptr_get((__sparse_force void __sparse_cache *) \
+				     (WIN3_MBASE + WIN3_OFFSET))))
+
+/**
+ * Initializer for struct perf_data_item_comp
+ *
+ * @param[out] perf Struct to be initialized
+ * @param[in] resource_id
+ * @param[in] power_mode
+ */
+void perf_data_item_comp_init(struct perf_data_item_comp *perf, uint32_t resource_id,
+			      uint32_t power_mode);
+
+/**
+ * Get next free performance data slot from Memory Window 3
+ *
+ * @return performance data record
+ */
+struct perf_data_item_comp *perf_data_getnext(void);
+
+/**
+ * Free a performance data slot in Memory Window 3
+ *
+ * @return 0 if succeeded, in other case the slot is already free
+ */
+int free_performance_data(struct perf_data_item_comp *item);
+
+/**
+ * Set performance measurements state
+ *
+ * @param[in] state Value to be set.
+ */
+void perf_meas_set_state(enum ipc4_perf_measurements_state_set state);
+
+/**
+ * Get performance measurements state
+ *
+ * @return performance measurements state
+ */
+enum ipc4_perf_measurements_state_set perf_meas_get_state(void);
+
 #endif