Re: [Intel-gfx] [PATCH] drm/i915/guc/slpc: Add a new SLPC selftest

On Fri, 10 Jun 2022 16:47:12 -0700, Vinay Belgaumkar wrote:

This test will validate we can achieve actual frequency of RP0. Pcode grants frequencies based on what GuC is requesting. However, thermal throttling can limit what is being granted. Add a test to request for max, but don't fail the test if RP0 is not granted due to throttle reasons.

Also optimize the selftest by using a common run_test function to avoid code duplication.

The refactoring does change the order of operations (changing the freq vs spawning the spinner) but should be fine I think.

Rename the "clamp" tests to vary_max_freq and vary_min_freq.

Either is ok, but maybe "clamp" names were ok I think since they verify req freq is clamped at min/max.

v2: Fix compile warning

Fixes 8ee2c227822e ("drm/i915/guc/slpc: Add SLPC selftest") Signed-off-by: Vinay Belgaumkar vinay.belgaumkar@intel.com

---

drivers/gpu/drm/i915/gt/selftest_slpc.c | 323 ++++++++++++------------ 1 file changed, 158 insertions(+), 165 deletions(-)

diff --git a/drivers/gpu/drm/i915/gt/selftest_slpc.c b/drivers/gpu/drm/i915/gt/selftest_slpc.c index b768cea5943d..099129aae9a5 100644 --- a/drivers/gpu/drm/i915/gt/selftest_slpc.c +++ b/drivers/gpu/drm/i915/gt/selftest_slpc.c @@ -8,6 +8,11 @@ #define delay_for_h2g() usleep_range(H2G_DELAY, H2G_DELAY + 10000) #define FREQUENCY_REQ_UNIT DIV_ROUND_CLOSEST(GT_FREQUENCY_MULTIPLIER, \ GEN9_FREQ_SCALER) +enum test_type {

• VARY_MIN,
• VARY_MAX,
• MAX_GRANTED

+};

static int slpc_set_min_freq(struct intel_guc_slpc *slpc, u32 freq) { @@ -36,147 +41,120 @@ static int slpc_set_max_freq(struct intel_guc_slpc *slpc, u32 freq) return ret; }

-static int live_slpc_clamp_min(void *arg) +static int vary_max_freq(struct intel_guc_slpc *slpc, struct intel_rps *rps,

•   u32 *max_act_freq)
  

Please run checkpatch, indentation seems off.

{

• struct drm_i915_private *i915 = arg;
• struct intel_gt *gt = to_gt(i915);
• struct intel_guc_slpc *slpc = &gt->uc.guc.slpc;
• struct intel_rps *rps = &gt->rps;
• struct intel_engine_cs *engine;
• enum intel_engine_id id;
• struct igt_spinner spin;

• u32 step, max_freq, req_freq;
• u32 act_freq; u32 slpc_min_freq, slpc_max_freq; int err = 0;

• if (!intel_uc_uses_guc_slpc(&gt->uc))

• return 0;
  

• if (igt_spinner_init(&spin, gt))

• return -ENOMEM;
  

• slpc_min_freq = slpc->min_freq;
• slpc_max_freq = slpc->rp0_freq;

nit but we don't really need such variables since we don't change their values, we should just use slpc->min_freq, slpc->rp0_freq directly. I'd change this in all places in this patch.

• if (intel_guc_slpc_get_max_freq(slpc, &slpc_max_freq)) {

• pr_err("Could not get SLPC max freq\n");
  

• return -EIO;
  

• }
• if (intel_guc_slpc_get_min_freq(slpc, &slpc_min_freq)) {

• pr_err("Could not get SLPC min freq\n");
  

• return -EIO;
  

Why do we need these two function calls? Can't we just use slpc->rp0_freq and slpc->min_freq as we are doing in the vary_min/max_freq() functions above?

Also, as mentioned below I think here we should just do:

slpc_set_max_freq(slpc, slpc->rp0_freq); slpc_set_min_freq(slpc, slpc->min_freq);

to restore freq to a known state before starting the test (just in case a previous test changed the values).

• }
• if (slpc_min_freq == slpc_max_freq) {

• pr_err("Min/Max are fused to the same value\n");
  

• return -EINVAL;
  

What if they are actually equal? I think basically the max/min freq test loops will just not be entered (so effectively the tests will just skip). The granted freq test will be fine. So I think we can just delete this if statement?

(It is showing deleted above in the patch but is in the new code somewhere too).

• }
• intel_gt_pm_wait_for_idle(gt);
• intel_gt_pm_get(gt);
• for_each_engine(engine, gt, id) {

• struct i915_request *rq;
  

• u32 step, min_freq, req_freq;
  

• u32 act_freq, max_act_freq;
  

• if (!intel_engine_can_store_dword(engine))
  

• 	continue;
  

• /* Go from max to min in 5 steps */
• step = (slpc_max_freq - slpc_min_freq) / NUM_STEPS;
• *max_act_freq = slpc_min_freq;
• for (max_freq = slpc_max_freq; max_freq > slpc_min_freq;

• 		max_freq -= step) {
  

• err = slpc_set_max_freq(slpc, max_freq);
  

• if (err)
  

• 	break;
  
  

• /* Go from min to max in 5 steps */
  

• step = (slpc_max_freq - slpc_min_freq) / NUM_STEPS;
  

• max_act_freq = slpc_min_freq;
  

• for (min_freq = slpc_min_freq; min_freq < slpc_max_freq;
  

• 			min_freq += step) {
  

• 	err = slpc_set_min_freq(slpc, min_freq);
  

• 	if (err)
  

• 		break;
  

• 	st_engine_heartbeat_disable(engine);
  

• 	rq = igt_spinner_create_request(&spin,
  

• 					engine->kernel_context,
  

• 					MI_NOOP);
  

• 	if (IS_ERR(rq)) {
  

• 		err = PTR_ERR(rq);
  

• 		st_engine_heartbeat_enable(engine);
  

• 		break;
  

• 	}
  

• req_freq = intel_rps_read_punit_req_frequency(rps);
  
  

• 	i915_request_add(rq);
  

• /* GuC requests freq in multiples of 50/3 MHz */
  

• if (req_freq > (max_freq + FREQUENCY_REQ_UNIT)) {
  

• 	pr_err("SWReq is %d, should be at most %d\n", req_freq,
  

• 		max_freq + FREQUENCY_REQ_UNIT);
  

• 	err = -EINVAL;
  

Probably a nit but check can be (so should we be checking both high and low limits?): if (req_freq > (max_freq + FREQUENCY_REQ_UNIT) || req_freq < (slpc_min_freq - FREQUENCY_REQ_UNIT))

Though if we do this we'd need to change the pr_err() or have two separate if statements. Not sure if it's worth it but thought I'll mention it.

+static int vary_min_freq(struct intel_guc_slpc *slpc, struct intel_rps *rps,

•   u32 *max_act_freq)
  

+{

• u32 step, min_freq, req_freq;
• u32 act_freq;
• u32 slpc_min_freq, slpc_max_freq;
• int err = 0;

• 	act_freq =  intel_rps_read_actual_frequency(rps);
  

• 	if (act_freq > max_act_freq)
  

• 		max_act_freq = act_freq;
  

• slpc_min_freq = slpc->min_freq;
• slpc_max_freq = slpc->rp0_freq;

• 	igt_spinner_end(&spin);
  

• 	st_engine_heartbeat_enable(engine);
  

• }
  

• /* Go from min to max in 5 steps */
• step = (slpc_max_freq - slpc_min_freq) / NUM_STEPS;
• *max_act_freq = slpc_min_freq;
• for (min_freq = slpc_min_freq; min_freq < slpc_max_freq;

• 		min_freq += step) {
  

• err = slpc_set_min_freq(slpc, min_freq);
  

• if (err)
  

• 	break;
  
  

• pr_info("Max actual frequency for %s was %d\n",
  

• 	engine->name, max_act_freq);
  

• req_freq = intel_rps_read_punit_req_frequency(rps);
  
  

• /* Actual frequency should rise above min */
  

• if (max_act_freq == slpc_min_freq) {
  

Nit again. This check is somewhere in the new code but I think a better check is

if (max_act_freq <= slpc_min_freq)

just in case the act freq for whatever reason falls below slpc_min_freq. Even if we know this is impossible (bugs make the impossible possible).

• 	pr_err("Actual freq did not rise above min\n");
  

• /* GuC requests freq in multiples of 50/3 MHz */
  

• if (req_freq < (min_freq - FREQUENCY_REQ_UNIT)) {
  

• 	pr_err("SWReq is %d, should be at least %d\n", req_freq,
  

• 		min_freq - FREQUENCY_REQ_UNIT);
  err = -EINVAL;
  

Again nit as above, but check can be: if (req_freq < (min_freq - FREQUENCY_REQ_UNIT) || req_freq > (slpc_max_freq + FREQUENCY_REQ_UNIT)) {

}

• act_freq =  intel_rps_read_actual_frequency(rps);
  

• if (act_freq > *max_act_freq)
  

• 	*max_act_freq = act_freq;
  

• if (err) break; }

• /* Restore min/max frequencies */
• slpc_set_max_freq(slpc, slpc_max_freq);
• slpc_set_min_freq(slpc, slpc_min_freq);

• return err;

+}

• if (igt_flush_test(gt->i915))

• err = -EIO;
  

+static int max_granted_freq(struct intel_guc_slpc *slpc, struct intel_rps *rps, u32 *max_act_freq) +{

• struct intel_gt *gt = rps_to_gt(rps);
• u32 perf_limit_reasons;
• int err = 0;

• intel_gt_pm_put(gt);
• igt_spinner_fini(&spin);
• intel_gt_pm_wait_for_idle(gt);

• err = slpc_set_min_freq(slpc, slpc->rp0_freq);
• if (err)

• return err;
  

• *max_act_freq = intel_rps_read_actual_frequency(rps);
• if (!(*max_act_freq == slpc->rp0_freq)) {

• /* Check if there was some throttling by pcode */
  

• perf_limit_reasons = intel_uncore_read(gt->uncore, GT0_PERF_LIMIT_REASONS);
  

• /* If not, this is an error */
  

• if (perf_limit_reasons && GT0_PERF_LIMIT_REASONS_MASK) {
  

• 	pr_err("Pcode did not grant max freq\n");
  

• 	err = -EINVAL;
  

Looks incorrect, probably something like: if (!(perf_limit_reasons & GT0_PERF_LIMIT_REASONS_MASK))

• }
  

• }

  return err;

}

-static int live_slpc_clamp_max(void *arg) +static int run_test(struct intel_gt *gt, int test_type) {

• struct drm_i915_private *i915 = arg;
• struct intel_gt *gt = to_gt(i915);
• struct intel_guc_slpc *slpc;
• struct intel_rps *rps;

• struct intel_guc_slpc *slpc = &gt->uc.guc.slpc;
• struct intel_rps *rps = &gt->rps; struct intel_engine_cs *engine; enum intel_engine_id id; struct igt_spinner spin;

• int err = 0; u32 slpc_min_freq, slpc_max_freq;
• slpc = &gt->uc.guc.slpc;
• rps = &gt->rps;

• int err = 0;

  if (!intel_uc_uses_guc_slpc(&gt->uc)) return 0;

@@ -203,69 +181,56 @@ static int live_slpc_clamp_max(void *arg) intel_gt_pm_get(gt); for_each_engine(engine, gt, id) { struct i915_request *rq;

• u32 max_freq, req_freq;
  

• u32 act_freq, max_act_freq;
  

• u32 step;
  

• u32 max_act_freq;
  
  

  if (!intel_engine_can_store_dword(engine)) continue;

• /* Go from max to min in 5 steps */
  

• step = (slpc_max_freq - slpc_min_freq) / NUM_STEPS;
  

• max_act_freq = slpc_min_freq;
  

• for (max_freq = slpc_max_freq; max_freq > slpc_min_freq;
  

• 			max_freq -= step) {
  

• 	err = slpc_set_max_freq(slpc, max_freq);
  

• 	if (err)
  

• 		break;
  

• 	st_engine_heartbeat_disable(engine);
  

• 	rq = igt_spinner_create_request(&spin,
  

• 					engine->kernel_context,
  

• 					MI_NOOP);
  

• 	if (IS_ERR(rq)) {
  

• 		st_engine_heartbeat_enable(engine);
  

• 		err = PTR_ERR(rq);
  

• 		break;
  

• 	}
  

• st_engine_heartbeat_disable(engine);
  
  

• 	i915_request_add(rq);
  

• rq = igt_spinner_create_request(&spin,
  

• 				engine->kernel_context,
  

• 				MI_NOOP);
  

• if (IS_ERR(rq)) {
  

• 	err = PTR_ERR(rq);
  

• 	st_engine_heartbeat_enable(engine);
  

• 	break;
  

• }
  
  

• 	if (!igt_wait_for_spinner(&spin, rq)) {
  

• 		pr_err("%s: SLPC spinner did not start\n",
  

• 		       engine->name);
  

• 		igt_spinner_end(&spin);
  

• 		st_engine_heartbeat_enable(engine);
  

• 		intel_gt_set_wedged(engine->gt);
  

• 		err = -EIO;
  

• 		break;
  

• 	}
  

• i915_request_add(rq);
  

• if (!igt_wait_for_spinner(&spin, rq)) {
  

• 	pr_err("%s: Spinner did not start\n",
  

• 	       engine->name);
  

• 	igt_spinner_end(&spin);
  

• 	st_engine_heartbeat_enable(engine);
  

• 	intel_gt_set_wedged(engine->gt);
  

• 	err = -EIO;
  

• 	break;
  

• }
  
  

• 	delay_for_h2g();
  

• switch (test_type) {
  
  

• 	/* Verify that SWREQ indeed was set to specific value */
  

• 	req_freq = intel_rps_read_punit_req_frequency(rps);
  

• case VARY_MIN:
  

• 	err = vary_min_freq(slpc, rps, &max_act_freq);
  

• 	break;
  

• case VARY_MAX:
  

• 	err = vary_max_freq(slpc, rps, &max_act_freq);
  

• 	break;
  
  

• 	/* GuC requests freq in multiples of 50/3 MHz */
  

• 	if (req_freq > (max_freq + FREQUENCY_REQ_UNIT)) {
  

• 		pr_err("SWReq is %d, should be at most %d\n", req_freq,
  

• 		       max_freq + FREQUENCY_REQ_UNIT);
  

• case MAX_GRANTED:
  

• 	/* Media engines have a different RP0 */
  

• 	if ((engine->class == VIDEO_DECODE_CLASS) ||
  

• 	    (engine->class == VIDEO_ENHANCEMENT_CLASS)) {
  	igt_spinner_end(&spin);
  	st_engine_heartbeat_enable(engine);
  

• 		err = -EINVAL;
  

• 		break;
  

• 		err = 0;
  

• 		continue;
  

I think it's preferable to move this media engine code out of the main loop into max_granted_freq() function if possible (maybe by faking max_act_freq if needed)?

	}

• 	act_freq =  intel_rps_read_actual_frequency(rps);
  

• 	if (act_freq > max_act_freq)
  

• 		max_act_freq = act_freq;
  

• 	st_engine_heartbeat_enable(engine);
  

• 	igt_spinner_end(&spin);
  

• 	if (err)
  

• 		break;
  

• 	err = max_granted_freq(slpc, rps, &max_act_freq);
  

• 	break;
  

  }

  pr_info("Max actual frequency for %s was %d\n",

@@ -277,31 +242,59 @@ static int live_slpc_clamp_max(void *arg) err = -EINVAL; }

• if (igt_flush_test(gt->i915)) {
  

• 	err = -EIO;
  

• 	break;
  

• }
  

• igt_spinner_end(&spin);
  

• st_engine_heartbeat_enable(engine);
  
  

  if (err) break; }

• /* Restore min/max freq */

• /* Restore min/max frequencies */ slpc_set_max_freq(slpc, slpc_max_freq); slpc_set_min_freq(slpc, slpc_min_freq);

As mentioned above maybe we should restore at the beginning of the test too (before the for_each_engine() loop) to start from a known state?

Anyway here maybe get rid of the variables and:

slpc_set_max_freq(slpc, slpc->rp0_freq); slpc_set_min_freq(slpc, slpc->min_freq);

Thanks. -- Ashutosh