Multi-CCS support in IGT
Subsystems (2)
v6 cover Multi-CCS support in IGT
From: Nishit Sharma <[email protected]>
Revision 1:
Added loop_kernel_duration in available pipelines. loop_kernel_duration holds sleep duration and during sleep GPU will be workng. Patch-1/3: loop_kernel_duration addition in available pipelines in lib/intel_compute.c. igt_skip is called in pipeline which doesn't support loop_kernel shader.
Patch-2/3: Added loop-duration-2s subtest in tests/intel/xe_compute to test if GPU is executing shader when sleep is called. This is verfied using gputop in another terminal. This also tests whether the test executed successfully in >= 2seconds of duration set Patch-3/3: Added eu-busy-10s test which creates multi threads depending on num_slices available and schedules workload on all ccs instances available. This also prints engine utlization in percentage while workload is executing.
v2:
- Addressed review comments from Zbyshek on description in Patch-1.
- Added execution time check in Patch-2 regarding single iteration of scheduling and executing workload on single instance of CCS engine.
v3:
- Added missing code section in Patch-1.
- Modified LOOP_DURATIOn macro to LOOP_DURATION_2s to avoid confusion.
- Used LOOP_DURATION_2s in place of LOOP_DURATION and adjusted sleep durations.
v4:
- Test will skip if sriov is enabled and sriov_numfs > 0.
- Test will continue runing if sriov_numvfs = 0
v5:
- Incorporated review comments (Zbigniew)
v6:
- Simplified logic to capture EU busyness
- Removed header which had pmu counter and engine instance logic
- Moved pthread_data structure to xe_compute file which is used during thread creation
v7:
- collective counters are set per compute engine available in t->eci
- fixed few nits
v8:
- Incorporated review comments (Zbigniew)
- After workload execution set back ccs_mode to default value
Nishit Sharma (3):
lib/intel_compute: loop_kernel_duration in Pipeline tests/intel/xe_compute: Add loop_duration_2s subtest tests/intel/xe_compute: Add eu-busy-10s test
lib/intel_compute.c | 26 ++- lib/intel_compute.h | 2 + tests/intel/xe_compute.c | 334 ++++++++++++++++++++++++++++++++++++++- tests/meson.build | 1 + 4 files changed, 361 insertions(+), 2 deletions(-)
Signature · 1 line
2.43.0
PATCH v6 1/3 lib/intel_compute: loop_kernel_duration in Pipeline
From: Nishit Sharma <[email protected]>
Incase of multi-ccs it is expected that all ccs engines will be busy. There's no existing code which keeps GPU busy for a specified duration, So we need to terminate loop kernel from CPU after the desired time has elapsed.
Introduce the loop_kernel_duration variable to control kernel execution duration in compute pipelines. Currently this is supported in xe2lg and xe3lpg pipelines.
--- lib/intel_compute.c | 26 +++++++++++++++++++++++++- lib/intel_compute.h | 2 ++ 2 files changed, 27 insertions(+), 1 deletion(-)
lib/intel_compute.c +25 -1
@@ -849,6 +849,9 @@ static void compute_exec(int fd, const unsigned char *kernel,uint16_t devid =intel_get_drm_devid (fd);int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1131,6 +1134,9 @@ static void xehp_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1343,6 +1349,9 @@ static void xehpc_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1731,6 +1740,9 @@ static void xelpg_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +if (user && (user->kernel || user->loop_kernel_duration)) +igt_skip ("Pipeline doesn't support loop_kernel\n" ); +bo_execenv_create (fd, &execenv, eci, user);/* Set dynamic sizes */
@@ -1818,6 +1830,7 @@ static void xe2lpg_compute_exec(int fd, const unsigned char *kernel,uint64_t bind_input_addr = (user && user->input_addr) ? user->input_addr :ADDR_INPUT ;uint64_t bind_output_addr = (user && user->output_addr) ? user->output_addr :ADDR_OUTPUT ;int entries =ARRAY_SIZE (bo_dict); +int64_t timeout_one_ns =1 ;bo_execenv_create (fd, &execenv, eci, user);
@@ -1849,7 +1862,18 @@ static void xe2lpg_compute_exec(int fd, const unsigned char *kernel,OFFSET_KERNEL ,0 , false, execenv.array_size); -bo_execenv_exec (&execenv,ADDR_BATCH ); +if (user && user->loop_kernel_duration) { +bo_execenv_exec_async (&execenv,ADDR_BATCH ); +igt_measured_usleep (user->loop_kernel_duration); +/* Check that the loop kernel has not completed yet */ +igt_assert_neq (0 ,__xe_wait_ufence (fd, &execenv.bo_sync->sync,USER_FENCE_VALUE , + execenv.exec_queue, &timeout_one_ns)); + ((int *)bo_dict[4 ].data)[0 ] =MAGIC_LOOP_STOP ; +bo_execenv_sync (&execenv); + user->skip_results_check =1 ; + }else { +bo_execenv_exec (&execenv,ADDR_BATCH ); + }if (!user || (user && !user->skip_results_check))bo_check_square (input_data, output_data, execenv.array_size);
lib/intel_compute.h +2 -0
@@ -63,6 +63,8 @@ struct user_execenv {uint64_t input_addr;/** @output_addr: override default address of the output array if provided */ uint64_t output_addr; +/** @loop_kernel_duration: duration till kernel should execute in gpu **/ +uint64_t loop_kernel_duration; };enum execenv_alloc_prefs {
Signature · 1 line
2.43.0
PATCH v6 2/3 tests/intel/xe_compute: Add loop_duration_2s subtest
In reply to [email protected]From: Nishit Sharma <[email protected]>
Verify introduced loop_kernel_duration parameter in user_execenv which makes GPU busy for specified duration. Execution should remain within a 0.2 second margin of the requested duration. loop_kernel shader is not supported in xehpc, xehp, xelpg pipelines so test will skip.
--- tests/intel/xe_compute.c | 61 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 61 insertions(+)
tests/intel/xe_compute.c +61 -0
@@ -19,6 +19,9 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#define LOOP_DURATION_2s (1000000ull * 2) +#define DURATION_MARGIN 0.2 +static int gt_sysfs_open (int gt) {int fd, gt_fd;
@@ -186,6 +189,60 @@ test_compute_kernel_with_ccs_mode(void)igt_require (num_gt_with_ccs_mode >0 ); } +static double elapsed (const struct timeval *start, +const struct timeval *end) +{ +return (end->tv_sec - start->tv_sec) +1e-6 *(end->tv_usec - start->tv_usec); +} + +/** +* SUBTEST: loop-duration-2s +* Functionality: OpenCL kernel +* Description: +* Run an openCL loop Kernel that for duration, +* set in loop_kernel_duration .. +*/ +static void +test_compute_kernel_loop (uint64_t loop_duration) +{ +int fd; +unsigned int ip_ver; +const struct intel_compute_kernels *kernels; +struct user_execenv execenv = {0 }; +struct drm_xe_engine_class_instance *hwe; +struct timeval start, end; + + fd =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; + +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* loop_kernel_duration used as sleep to make EU busy for loop_duration */ + execenv.loop_kernel_duration = loop_duration; + execenv.kernel = kernels->loop_kernel; + execenv.kernel_size = kernels->loop_kernel_size; + +xe_for_each_engine (fd, hwe) { +if (hwe->engine_class !=DRM_XE_ENGINE_CLASS_COMPUTE ) +continue ; + +igt_info ("Running loop_kernel on ccs engine %d\n" , hwe->engine_instance); +gettimeofday (&start,NULL ); +igt_assert_f (xe_run_intel_compute_kernel_on_engine (fd, hwe, &execenv, +EXECENV_PREF_SYSTEM ), +"Unable to run compute kernel successfully\n" ); +gettimeofday (&end,NULL ); +igt_assert ((double )(loop_duration / LOOP_DURATION_2s -DURATION_MARGIN ) <elapsed (&start, &end) && + (double )(loop_duration / LOOP_DURATION_2s +DURATION_MARGIN )); + } +drm_close_driver (fd); +} +/** * SUBTEST: compute-square * Mega feature: WMTP
@@ -223,4 +280,8 @@ igt_main igt_subtest("ccs-mode-compute-kernel")test_compute_kernel_with_ccs_mode (); + +/* To test compute function stops after loop_kernel_duration */ + igt_subtest("loop-duration-2s") +test_compute_kernel_loop (LOOP_DURATION_2s); }
Signature · 1 line
2.43.0
PATCH v6 3/3 tests/intel/xe_compute: Add eu-busy-10s test
In reply to [email protected]From: Nishit Sharma <[email protected]>
Add multi threading to utilize available CCS instances as per num_slices available in /sys/class/drm/cardX/device/tileX/gtX/num_cslices. Depending upon num_slices, number of threads will be created and schedule compute workload in different CCS instances. Sleep is called via loop_kernel_duration so that HW engine runs for sleep duration. During execution per EU utlization percentage is grabbed and displayed on console. Added igt_skip() if sriov is enabled in platform, so if sriov_numvfs > 0 then test will be skipped.
--- tests/intel/xe_compute.c | 273 ++++++++++++++++++++++++++++++++++++++- tests/meson.build | 1 + 2 files changed, 273 insertions(+), 1 deletion(-)
tests/intel/xe_compute.c +272 -1
@@ -19,9 +19,24 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#include "igt_perf.h" +#include "igt_sriov_device.h" +#define LOOP_DURATION_2s (1000000ull * 2)#define DURATION_MARGIN 0.2 +struct thread_data { +pthread_t thread; +pthread_mutex_t *mutex; +pthread_cond_t *cond; +int class; +int fd; +int gt; +struct user_execenv *execenv; +struct drm_xe_engine_class_instance *eci; +bool *go; +}; +static int gt_sysfs_open (int gt) {int fd, gt_fd;
@@ -243,6 +258,233 @@ test_compute_kernel_loop(uint64_t loop_duration)drm_close_driver (fd); } +static void +*intel_compute_thread (void *data) +{ +struct thread_data *t = (struct thread_data *)data; +char device[30 ]; +uint64_t type; +uint32_t engine_class, engine_instance, gt_shift; +uint64_t engine_active_config, engine_total_config; +int ret, fd1, fd2; +uint64_t val[4 ]; +uint64_t param_config; + +pthread_mutex_lock (t->mutex); +while (*t->go ==0 ) +pthread_cond_wait (t->cond, t->mutex); +pthread_mutex_unlock (t->mutex); + + type =igt_perf_type_id (xe_perf_device (t->fd, device,sizeof (device))); +igt_debug ("type: %lx, device: %s\n" , type, device); + +perf_event_format (device,"gt" , >_shift); +perf_event_format (device,"engine_class" , &engine_class); +perf_event_format (device,"engine_instance" , &engine_instance); + + ret =perf_event_config (device,"engine-active-ticks" , &engine_active_config); +igt_assert_eq (ret,0 ); + ret =perf_event_config (device,"engine-total-ticks" , &engine_total_config); +igt_assert_eq (ret,0 ); + +igt_debug ("gt_id: %x, class: %x, instance: %x\n" , + t->eci->gt_id, t->eci->engine_class, t->eci->engine_instance); + +/* Setting collective counters for compute engine available in t->eci */ + param_config = (uint64_t )t->eci->gt_id << gt_shift | + t->eci->engine_class << engine_class | + t->eci->engine_instance << engine_instance; + + fd1 =igt_perf_open_group (type, engine_active_config | param_config,-1 ); + fd2 =igt_perf_open_group (type, engine_total_config | param_config, fd1); +igt_debug ("fd1: %d, fd2: %d\n" , fd1, fd2); + + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("start - active: %ld, total: %ld, busyness: %.1f before scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); + +igt_assert_f (xe_run_intel_compute_kernel_on_engine (t->fd, t->eci, t->execenv, +EXECENV_PREF_VRAM_IF_POSSIBLE ), +"Unable to run compute kernel successfully\n" ); + + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("end - active: %ld, total: %ld, busyness: %.1f after scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); + +igt_assert_f (((float )val[2 ] / (float )val[3 ] *100.0 ) >50.0 , +"Engines utilization is below 50 perc\n" ); + +close (fd1); +close (fd2); +return NULL ; +} + +static void +igt_check_supported_pipeline (void ) +{ +int fd; +unsigned int ip_ver; +const struct intel_compute_kernels *kernels; + + fd =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; + +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* skip if loop_kernel is not supported by pipeline */ +if (!kernels->kernel || !kernels->loop_kernel) { +drm_close_driver (fd); +igt_skip ("loop_kernel not supported by pipeline\n" ); + }else { +igt_info ("loop kernel supported by pipeline\n" ); +drm_close_driver (fd); + } +} + +static void +igt_check_sriov (void ) +{ +int fd =drm_open_driver (DRIVER_XE ); + +if (igt_sriov_is_pf (fd) &&igt_sriov_vfs_supported (fd)) { +drm_close_driver (fd); +igt_skip ("Skipping test when SRIOV is enabled\n" ); + } +drm_close_driver (fd); +} + +static void +igt_set_ccs_default_value (int ccs_mode[],int size) +{ +uint64_t gt_mask =get_gt_mask (); +u32 gt, num_slices; +int gt_fd; + +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , ccs_mode[gt]) >0 ); +close (gt_fd); + } +} + +/** +* SUBTEST: eu-busy-10s +* Functionality: OpenCL kernel +* Description: Run loop_kernel for duration_sec and observe EU business +*/ +static void +test_eu_busy (uint64_t duration_sec) +{ +struct user_execenv execenv = {0 }; +struct thread_data *threads_data; +struct drm_xe_engine_class_instance *hwe; +const struct intel_compute_kernels *kernels; +pthread_mutex_t mutex; +pthread_cond_t cond; +u32 gt, n_threads =0 , iterations =0 , n_instances =0 , i; +bool go = false; +int ccs_mode, gt_fd, fd; +u32 num_slices, ip_ver; +uint64_t gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , num_slices) >0 ); +igt_assert (igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode) >0 ); +close (gt_fd); + } + +igt_skip_on_f (ccs_mode <=1 ,"Skipping test as ccs_mode <=1 not matching criteria :%d\n" , + ccs_mode); + + fd =drm_open_driver (DRIVER_XE ); + + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* +* User should use different kernel if loop_kernel_duration not set +* With loop kernel and loop duration it assumes we stop it via memory write +* +*/ + + execenv.loop_kernel_duration = duration_sec; + execenv.kernel = kernels->loop_kernel; + execenv.kernel_size = kernels->loop_kernel_size; +drm_close_driver (fd); + + gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { + fd =drm_open_driver (DRIVER_XE ); +xe_for_each_engine (fd, hwe) { +igt_assert (hwe); +if (hwe->engine_class ==DRM_XE_ENGINE_CLASS_COMPUTE ) + ++n_instances; + } +drm_close_driver (fd); + } + + threads_data =calloc (n_instances,sizeof (*threads_data)); +igt_assert (threads_data); + +pthread_mutex_init (&mutex,0 ); +pthread_cond_init (&cond,0 ); + + gt_mask =get_gt_mask (); + fd =drm_open_driver (DRIVER_XE ); +for_each_bit (gt_mask, gt) { +xe_for_each_engine (fd, hwe) { +if (hwe->gt_id != gt || + hwe->engine_class !=DRM_XE_ENGINE_CLASS_COMPUTE ) +continue ; + + threads_data[i].mutex = &mutex; + threads_data[i].cond = &cond; + threads_data[i].fd = fd; + threads_data[i].eci = hwe; + threads_data[i].go = &go; + threads_data[i].execenv = &execenv; + ++n_threads; +pthread_create (&threads_data[i].thread,0 , intel_compute_thread, + &threads_data[i]); + ++i; + ++iterations; + } +pthread_mutex_lock (&mutex); + go = true; +pthread_cond_broadcast (&cond); +pthread_mutex_unlock (&mutex); + +for (int val =0 ; val < i; ++val) +pthread_join (threads_data[val].thread,NULL ); + + i =0 ; + n_threads =0 ; + iterations =0 ; + } +free (threads_data); +drm_close_driver (fd); +} +/** * SUBTEST: compute-square * Mega feature: WMTP
@@ -262,10 +504,22 @@ test_compute_square(int fd) igt_main { -int xe; +int xe, ccs_mode[4 ], gt_fd, gt; +unsigned int ip_ver; +u32 num_slices; +uint64_t gt_mask =get_gt_mask (); igt_fixture { xe =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (xe)); +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode[gt]); +close (gt_fd); + } }igt_subtest ("compute-square" )
@@ -284,4 +538,21 @@ igt_main/* To test compute function stops after loop_kernel_duration */ igt_subtest("loop-duration-2s")test_compute_kernel_loop (LOOP_DURATION_2s); + +/* test to check available EU utilisation in multi-ccs case */ + igt_subtest("eu-busy-10s") { +/* skip test if loop_kernel not supported in pipeline */ +if (ip_ver <IP_VER (20 ,0 )) +igt_check_supported_pipeline (); + +/* skip if sriov enabled */ +igt_check_sriov (); + +test_eu_busy (5 * LOOP_DURATION_2s); +/* calling sleep to make sure EUs done with execution */ +sleep (3 ); + } + +igt_fixture + igt_set_ccs_default_value(ccs_mode, sizeof(ccs_mode)); }
tests/meson.build +1 -0
@@ -408,6 +408,7 @@ extra_dependencies = { 'sw_sync': [ libatomic ], 'xe_fault_injection': [ lib_igt_xe_oa ], 'xe_oa': [ lib_igt_xe_oa ], + 'xe_compute': [ igt_deps,lib_igt_perf,lib_igt_profiling,math ], } test_executables = []
Signature · 1 line
2.43.0
Re: [PATCH i-g-t v6 3/3] tests/intel/xe_compute: Add eu-busy-10s test
Quoted 281 lines · On Fri, Oct 03, 2025 at 11:31:49AM +0000, [email protected] wrote:
From: Nishit Sharma <[email protected]>
Add multi threading to utilize available CCS instances as per
num_slicesavailable in/sys/class/drm/cardX/device/tileX/gtX/num_cslices. Depending uponnum_slices, number of threads will be created and schedule compute workload in different CCS instances. Sleep is called vialoop_kernel_durationso that HW engine runs for sleep duration. During execution per EU utlization percentage is grabbed and displayed on console. Addedigt_skip()if sriov is enabled in platform, so ifsriov_numvfs> 0 then test will be skipped.Signed-off-by Nishit Sharma <[email protected]>--- tests/intel/xe_compute.c | 273 ++++++++++++++++++++++++++++++++++++++- tests/meson.build | 1 + 2 files changed, 273 insertions(+), 1 deletion(-)tests/intel/xe_compute.c +242
-0@@ -19,9 +19,24 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#include "igt_perf.h" +#include "igt_sriov_device.h" +#define LOOP_DURATION_2s (1000000ull * 2)#define DURATION_MARGIN 0.2 +struct thread_data { +pthread_t thread; +pthread_mutex_t *mutex; +pthread_cond_t *cond; +int class; +int fd; +int gt; +struct user_execenv *execenv; +struct drm_xe_engine_class_instance *eci; +bool *go; +}; +static int gt_sysfs_open (int gt) {int fd, gt_fd;@@ -243,6 +258,233 @@ test_compute_kernel_loop(uint64_t loop_duration)drm_close_driver (fd); } +static void +*intel_compute_thread (void *data) +{ +struct thread_data *t = (struct thread_data *)data; +char device[30 ]; +uint64_t type; +uint32_t engine_class, engine_instance, gt_shift; +uint64_t engine_active_config, engine_total_config; +int ret, fd1, fd2; +uint64_t val[4 ]; +uint64_t param_config; + +pthread_mutex_lock (t->mutex); +while (*t->go ==0 ) +pthread_cond_wait (t->cond, t->mutex); +pthread_mutex_unlock (t->mutex); + + type =igt_perf_type_id (xe_perf_device (t->fd, device,sizeof (device))); +igt_debug ("type: %lx, device: %s\n" , type, device); + +perf_event_format (device,"gt" , >_shift); +perf_event_format (device,"engine_class" , &engine_class); +perf_event_format (device,"engine_instance" , &engine_instance); + + ret =perf_event_config (device,"engine-active-ticks" , &engine_active_config); +igt_assert_eq (ret,0 ); + ret =perf_event_config (device,"engine-total-ticks" , &engine_total_config); +igt_assert_eq (ret,0 ); + +igt_debug ("gt_id: %x, class: %x, instance: %x\n" , + t->eci->gt_id, t->eci->engine_class, t->eci->engine_instance); + +/* Setting collective counters for compute engine available in t->eci */ + param_config = (uint64_t )t->eci->gt_id << gt_shift | + t->eci->engine_class << engine_class | + t->eci->engine_instance << engine_instance; + + fd1 =igt_perf_open_group (type, engine_active_config | param_config,-1 ); + fd2 =igt_perf_open_group (type, engine_total_config | param_config, fd1); +igt_debug ("fd1: %d, fd2: %d\n" , fd1, fd2); + + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("start - active: %ld, total: %ld, busyness: %.1f before scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); + +igt_assert_f (xe_run_intel_compute_kernel_on_engine (t->fd, t->eci, t->execenv, +EXECENV_PREF_VRAM_IF_POSSIBLE ), +"Unable to run compute kernel successfully\n" ); + + ret =read (fd1, val,sizeof (val)); +igt_assert_eq (ret,sizeof (val)); +igt_info ("end - active: %ld, total: %ld, busyness: %.1f after scheduling on engine_instance :%d\n" , + val[2 ], val[3 ], (float )val[2 ] / (float )val[3 ] *100.0 , t->eci->engine_instance); + +igt_assert_f (((float )val[2 ] / (float )val[3 ] *100.0 ) >50.0 , +"Engines utilization is below 50 perc\n" ); + +close (fd1); +close (fd2); +return NULL ; +} + +static void +igt_check_supported_pipeline (void ) +{ +int fd; +unsigned int ip_ver; +const struct intel_compute_kernels *kernels; + + fd =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; + +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* skip if loop_kernel is not supported by pipeline */ +if (!kernels->kernel || !kernels->loop_kernel) { +drm_close_driver (fd); +igt_skip ("loop_kernel not supported by pipeline\n" ); + }else { +igt_info ("loop kernel supported by pipeline\n" ); +drm_close_driver (fd); + } +} + +static void +igt_check_sriov (void ) +{ +int fd =drm_open_driver (DRIVER_XE ); + +if (igt_sriov_is_pf (fd) &&igt_sriov_vfs_supported (fd)) { +drm_close_driver (fd); +igt_skip ("Skipping test when SRIOV is enabled\n" ); + } +drm_close_driver (fd); +} + +static void +igt_set_ccs_default_value (int ccs_mode[],int size) +{ +uint64_t gt_mask =get_gt_mask (); +u32 gt, num_slices; +int gt_fd; + +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , ccs_mode[gt]) >0 ); +close (gt_fd); + } +} + +/** +* SUBTEST: eu-busy-10s +* Functionality: OpenCL kernel +* Description: Run loop_kernel for duration_sec and observe EU business +*/ +static void +test_eu_busy (uint64_t duration_sec) +{ +struct user_execenv execenv = {0 }; +struct thread_data *threads_data; +struct drm_xe_engine_class_instance *hwe; +const struct intel_compute_kernels *kernels; +pthread_mutex_t mutex; +pthread_cond_t cond; +u32 gt, n_threads =0 , iterations =0 , n_instances =0 , i; +bool go = false; +int ccs_mode, gt_fd, fd; +u32 num_slices, ip_ver; +uint64_t gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_assert (igt_sysfs_printf (gt_fd,"ccs_mode" ,"%u" , num_slices) >0 ); +igt_assert (igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode) >0 ); +close (gt_fd); + } + +igt_skip_on_f (ccs_mode <=1 ,"Skipping test as ccs_mode <=1 not matching criteria :%d\n" , + ccs_mode); + + fd =drm_open_driver (DRIVER_XE ); + + ip_ver =intel_graphics_ver (intel_get_drm_devid (fd)); + kernels = intel_compute_square_kernels; +while (kernels->kernel) { +if (ip_ver == kernels->ip_ver) +break ; + kernels++; + } + +/* +* User should use different kernel if loop_kernel_duration not set +* With loop kernel and loop duration it assumes we stop it via memory write +* +*/ + + execenv.loop_kernel_duration = duration_sec; + execenv.kernel = kernels->loop_kernel; + execenv.kernel_size = kernels->loop_kernel_size; +drm_close_driver (fd); + + gt_mask =get_gt_mask (); + +for_each_bit (gt_mask, gt) { + fd =drm_open_driver (DRIVER_XE ); +xe_for_each_engine (fd, hwe) { +igt_assert (hwe); +if (hwe->engine_class ==DRM_XE_ENGINE_CLASS_COMPUTE ) + ++n_instances; + } +drm_close_driver (fd); + } + + threads_data =calloc (n_instances,sizeof (*threads_data)); +igt_assert (threads_data); + +pthread_mutex_init (&mutex,0 ); +pthread_cond_init (&cond,0 ); + + gt_mask =get_gt_mask (); + fd =drm_open_driver (DRIVER_XE ); +for_each_bit (gt_mask, gt) { +xe_for_each_engine (fd, hwe) { +if (hwe->gt_id != gt || + hwe->engine_class !=DRM_XE_ENGINE_CLASS_COMPUTE ) +continue ; + + threads_data[i].mutex = &mutex; + threads_data[i].cond = &cond; + threads_data[i].fd = fd; + threads_data[i].eci = hwe; + threads_data[i].go = &go; + threads_data[i].execenv = &execenv; + ++n_threads; +pthread_create (&threads_data[i].thread,0 , intel_compute_thread, + &threads_data[i]); + ++i; + ++iterations; + } +pthread_mutex_lock (&mutex); + go = true; +pthread_cond_broadcast (&cond); +pthread_mutex_unlock (&mutex); + +for (int val =0 ; val < i; ++val) +pthread_join (threads_data[val].thread,NULL ); + + i =0 ; + n_threads =0 ; + iterations =0 ; + } +free (threads_data); +drm_close_driver (fd); +} +/** * SUBTEST: compute-square * Mega feature: WMTP
tests/intel/xe_compute.c test_compute_square(int fd) · line 510
Quoted 8 lines
tests/intel/xe_compute.c +4
-1@@ -262,10 +504,22 @@ test_compute_square(int fd) igt_main { -int xe; +int xe, ccs_mode[4 ], gt_fd, gt; +unsigned int ip_ver; +u32 num_slices; +uint64_t gt_mask =get_gt_mask ();
Calling get_gt_mask() here is not good idea and according to testlist processing it even fail the build.
Please fix and resubmit.
--
Zbigniew
Quoted 52 lines
tests/intel/xe_compute.c +26
-0igt_fixture { xe =drm_open_driver (DRIVER_XE ); + ip_ver =intel_graphics_ver (intel_get_drm_devid (xe)); +for_each_bit (gt_mask, gt) { +if (!get_num_cslices (gt, &num_slices)) +continue ; + + gt_fd =gt_sysfs_open (gt); +igt_sysfs_scanf (gt_fd,"ccs_mode" ,"%u" , &ccs_mode[gt]); +close (gt_fd); + } }igt_subtest ("compute-square" )@@ -284,4 +538,21 @@ igt_main/* To test compute function stops after loop_kernel_duration */ igt_subtest("loop-duration-2s")test_compute_kernel_loop (LOOP_DURATION_2s); + +/* test to check available EU utilisation in multi-ccs case */ + igt_subtest("eu-busy-10s") { +/* skip test if loop_kernel not supported in pipeline */ +if (ip_ver <IP_VER (20 ,0 )) +igt_check_supported_pipeline (); + +/* skip if sriov enabled */ +igt_check_sriov (); + +test_eu_busy (5 * LOOP_DURATION_2s); +/* calling sleep to make sure EUs done with execution */ +sleep (3 ); + } + +igt_fixture + igt_set_ccs_default_value(ccs_mode, sizeof(ccs_mode)); }tests/meson.build +1
-0@@ -408,6 +408,7 @@ extra_dependencies = { 'sw_sync': [ libatomic ], 'xe_fault_injection': [ lib_igt_xe_oa ], 'xe_oa': [ lib_igt_xe_oa ], + 'xe_compute': [ igt_deps,lib_igt_perf,lib_igt_profiling,math ], } test_executables = []Signature · 1 line
2.43.0