From patchwork Tue Apr 11 09:20:32 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Mika Kahola X-Patchwork-Id: 9674791 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 78F9660381 for ; Tue, 11 Apr 2017 09:23:19 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 7A81F28517 for ; Tue, 11 Apr 2017 09:23:19 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 6F41628521; Tue, 11 Apr 2017 09:23:19 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.2 required=2.0 tests=BAYES_00, RCVD_IN_DNSWL_MED autolearn=ham version=3.3.1 Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 71B1D28517 for ; Tue, 11 Apr 2017 09:23:18 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id E9EDD89BC0; Tue, 11 Apr 2017 09:23:17 +0000 (UTC) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1012B89BC0 for ; Tue, 11 Apr 2017 09:23:17 +0000 (UTC) Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga105.jf.intel.com with ESMTP; 11 Apr 2017 02:23:15 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.37,184,1488873600"; d="scan'208";a="954683040" Received: from sorvi.fi.intel.com ([10.237.72.182]) by orsmga003.jf.intel.com with ESMTP; 11 Apr 2017 02:23:15 -0700 From: Mika Kahola To: intel-gfx@lists.freedesktop.org Date: Tue, 11 Apr 2017 12:20:32 +0300 Message-Id: <1491902432-13731-1-git-send-email-mika.kahola@intel.com> X-Mailer: git-send-email 2.7.4 MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH i-g-t v3] tests/kms_concurrent: Concurrent and interruptible subtests for atomic X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Virus-Scanned: ClamAV using ClamSMTP This test case introduces concurrently running test cases for atomic modesetting. The first test or thread draws blue backround with black holes on it. These holes are covered by rectangular, blue planes that are placed randomly like in test case 'kms_plane_multiple'. The second thread changes resolution from higher to lower one and back. For: VIZ-7022 v2: use igt_fork instead of pthreads to create concurrent test runs (Maarten) v3: use igt_display calls instead of raw drm calls for display updates (Maarten) Various cleanups on accessing drm connector (Maarten) Signed-off-by: Mika Kahola Reviewed-by: Maarten Lankhorst --- tests/Makefile.sources | 1 + tests/kms_concurrent.c | 429 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 430 insertions(+) create mode 100644 tests/kms_concurrent.c diff --git a/tests/Makefile.sources b/tests/Makefile.sources index 45c21a0..65ffbf9 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -115,6 +115,7 @@ TESTS_progs_M = \ kms_plane \ kms_plane_multiple \ kms_plane_lowres \ + kms_concurrent \ kms_properties \ kms_psr_sink_crc \ kms_render \ diff --git a/tests/kms_concurrent.c b/tests/kms_concurrent.c new file mode 100644 index 0000000..b34540b --- /dev/null +++ b/tests/kms_concurrent.c @@ -0,0 +1,429 @@ +/* + * Copyright © 2017 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + */ + +#include "igt.h" +#include "drmtest.h" + +IGT_TEST_DESCRIPTION("Test atomic mode setting concurrently with multiple planes and screen resolution"); + +#define SIZE_PLANE 256 +#define SIZE_CURSOR 128 +#define LOOP_FOREVER -1 + +typedef struct { + int drm_fd; + igt_display_t display; + igt_plane_t **plane; + struct igt_fb *fb; +} data_t; + +/* Command line parameters. */ +struct { + int iterations; + bool user_seed; + int seed; + bool run; +} opt = { + .iterations = 1, + .user_seed = false, + .seed = 1, + .run = true, +}; + +/* + * Common code across all tests, acting on data_t + */ +static void test_init(data_t *data, enum pipe pipe, int n_planes, + igt_output_t *output) +{ + drmModeModeInfo *mode; + igt_plane_t *primary; + int ret; + + data->plane = calloc(n_planes, sizeof(data->plane)); + igt_assert_f(data->plane != NULL, "Failed to allocate memory for planes\n"); + + data->fb = calloc(n_planes, sizeof(struct igt_fb)); + igt_assert_f(data->fb != NULL, "Failed to allocate memory for FBs\n"); + + igt_output_set_pipe(output, pipe); + + primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); + data->plane[primary->index] = primary; + + mode = igt_output_get_mode(output); + + igt_create_color_fb(data->drm_fd, mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + LOCAL_I915_FORMAT_MOD_X_TILED, + 0.0f, 0.0f, 1.0f, + &data->fb[primary->index]); + + igt_plane_set_fb(data->plane[primary->index], &data->fb[primary->index]); + + ret = igt_display_try_commit2(&data->display, COMMIT_ATOMIC); + igt_skip_on(ret != 0); +} + +static void test_fini(data_t *data, enum pipe pipe, int n_planes, + igt_output_t *output) +{ + int i; + + data->display.pipes[pipe].mode_blob = 0; + + for (i = 0; i < n_planes; i++) { + igt_plane_t *plane = data->plane[i]; + + if (!plane) + continue; + + if (plane->type == DRM_PLANE_TYPE_PRIMARY) + continue; + + igt_plane_set_fb(plane, NULL); + + data->plane[i] = NULL; + } + + /* reset the constraint on the pipe */ + igt_output_set_pipe(output, PIPE_ANY); + + free(data->plane); + data->plane = NULL; + + free(data->fb); + data->fb = NULL; +} + +static void +create_fb_for_mode_position(data_t *data, drmModeModeInfo *mode, + int *rect_x, int *rect_y, + int *rect_w, int *rect_h, + uint64_t tiling, int max_planes, + igt_output_t *output) +{ + unsigned int fb_id; + cairo_t *cr; + igt_plane_t *primary; + + primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); + + fb_id = igt_create_fb(data->drm_fd, + mode->hdisplay, mode->vdisplay, + DRM_FORMAT_XRGB8888, + tiling, + &data->fb[primary->index]); + igt_assert(fb_id); + + cr = igt_get_cairo_ctx(data->drm_fd, &data->fb[primary->index]); + igt_paint_color(cr, rect_x[0], rect_y[0], + mode->hdisplay, mode->vdisplay, + 0.0f, 0.0f, 1.0f); + + for (int i = 0; i < max_planes; i++) { + if (data->plane[i]->type == DRM_PLANE_TYPE_PRIMARY) + continue; + + igt_paint_color(cr, rect_x[i], rect_y[i], + rect_w[i], rect_h[i], 0.0, 0.0, 0.0); + } + + igt_assert(cairo_status(cr) == 0); + cairo_destroy(cr); +} + +static void +prepare_planes(data_t *data, enum pipe pipe, int max_planes, + igt_output_t *output) +{ + drmModeModeInfo *mode; + igt_pipe_t *p; + igt_plane_t *primary; + int *x; + int *y; + int *size; + int i; + + igt_output_set_pipe(output, pipe); + + primary = igt_output_get_plane_type(output, DRM_PLANE_TYPE_PRIMARY); + p = primary->pipe; + + x = malloc(p->n_planes * sizeof(*x)); + igt_assert_f(x, "Failed to allocate %ld bytes for variable x\n", (long int) (p->n_planes * sizeof(*x))); + + y = malloc(p->n_planes * sizeof(*y)); + igt_assert_f(y, "Failed to allocate %ld bytes for variable y\n", (long int) (p->n_planes * sizeof(*y))); + + size = malloc(p->n_planes * sizeof(*size)); + igt_assert_f(size, "Failed to allocate %ld bytes for variable size\n", (long int) (p->n_planes * sizeof(*size))); + + mode = igt_output_get_mode(output); + + /* planes with random positions */ + x[primary->index] = 0; + y[primary->index] = 0; + for (i = 0; i < max_planes; i++) { + igt_plane_t *plane = igt_output_get_plane(output, i); + + if (plane->type == DRM_PLANE_TYPE_PRIMARY) + continue; + else if (plane->type == DRM_PLANE_TYPE_CURSOR) + size[i] = SIZE_CURSOR; + else + size[i] = SIZE_PLANE; + + x[i] = rand() % (mode->hdisplay - size[i]); + y[i] = rand() % (mode->vdisplay - size[i]); + + data->plane[i] = plane; + + igt_create_color_fb(data->drm_fd, + size[i], size[i], + data->plane[i]->type == DRM_PLANE_TYPE_CURSOR ? DRM_FORMAT_ARGB8888 : DRM_FORMAT_XRGB8888, + data->plane[i]->type == DRM_PLANE_TYPE_CURSOR ? LOCAL_DRM_FORMAT_MOD_NONE : LOCAL_I915_FORMAT_MOD_X_TILED, + 0.0f, 0.0f, 1.0f, + &data->fb[i]); + + igt_plane_set_position(data->plane[i], x[i], y[i]); + igt_plane_set_fb(data->plane[i], &data->fb[i]); + } + + /* primary plane */ + data->plane[primary->index] = primary; + create_fb_for_mode_position(data, mode, x, y, size, size, + LOCAL_I915_FORMAT_MOD_X_TILED, + max_planes, output); + + igt_plane_set_fb(data->plane[primary->index], &data->fb[primary->index]); +} + +static void +test_plane_position_with_output(data_t *data, enum pipe pipe, igt_output_t *output) +{ + int i; + int iterations = opt.iterations < 1 ? 1 : opt.iterations; + bool loop_forever = opt.iterations == LOOP_FOREVER ? true : false; + int max_planes = data->display.pipes[pipe].n_planes; + + i = 0; + while (i < iterations || loop_forever) { + prepare_planes(data, pipe, max_planes, output); + igt_display_commit2(&data->display, COMMIT_ATOMIC); + + i++; + } +} + +static drmModeModeInfo * +get_lowres_mode(data_t *data, drmModeModeInfo *mode_default, + igt_output_t *output) +{ + drmModeModeInfo std_1024_mode = { + .clock = 65000, + .hdisplay = 1024, + .hsync_start = 1048, + .hsync_end = 1184, + .htotal = 1344, + .hskew = 0, + .vdisplay = 768, + .vsync_start = 771, + .vsync_end = 777, + .vtotal = 806, + .vscan = 0, + .vrefresh = 60, + .flags = 0xA, + .type = 0x40, + .name = "Custom 1024x768", + }; + drmModeModeInfo *mode = &std_1024_mode; + drmModeConnector *connector = output->config.connector; + int limit = mode_default->vdisplay - SIZE_PLANE; + bool found; + + if (!connector) + return mode; + + found = false; + for (int i = 0; i < connector->count_modes; i++) { + mode = &connector->modes[i]; + + if (mode->vdisplay < limit) { + found = true; + break; + } + } + + if (!found) + mode = &std_1024_mode; + + return mode; +} + +static void +test_resolution_with_output(data_t *data, enum pipe pipe, igt_output_t *output) +{ + drmModeModeInfo *mode_hi, *mode_lo; + int iterations = opt.iterations < 1 ? 1 : opt.iterations; + bool loop_forever = opt.iterations == LOOP_FOREVER ? true : false; + int i; + + i = 0; + while (i < iterations || loop_forever) { + data->display.pipes[pipe].mode_blob = 0; + + mode_hi = igt_output_get_mode(output); + mode_lo = get_lowres_mode(data, mode_hi, output); + + /* switch to lower resolution */ + igt_output_override_mode(output, mode_lo); + igt_output_set_pipe(output, pipe); + igt_display_commit2(&data->display, COMMIT_ATOMIC); + + /* switch back to higher resolution */ + igt_output_override_mode(output, NULL); + igt_output_set_pipe(output, pipe); + igt_display_commit2(&data->display, COMMIT_ATOMIC); + + i++; + } +} + +static void +run_test(data_t *data, enum pipe pipe, igt_output_t *output) +{ + int connected_outs; + int n_planes = data->display.pipes[pipe].n_planes; + + if (!opt.user_seed) + opt.seed = time(NULL); + + connected_outs = 0; + for_each_valid_output_on_pipe(&data->display, pipe, output) { + igt_info("Testing resolution with connector %s using pipe %s with seed %d\n", + igt_output_name(output), kmstest_pipe_name(pipe), opt.seed); + + test_init(data, pipe, n_planes, output); + + igt_fork(child, 1) { + test_plane_position_with_output(data, pipe, output); + } + + test_resolution_with_output(data, pipe, output); + + igt_waitchildren(); + + test_fini(data, pipe, n_planes, output); + + connected_outs++; + } + + igt_skip_on(connected_outs == 0); +} + +static void +run_tests_for_pipe(data_t *data, enum pipe pipe) +{ + igt_output_t *output; + + igt_fixture { + int valid_tests = 0; + + igt_require(data->display.pipes[pipe].n_planes > 0); + igt_skip_on(pipe >= data->display.n_pipes); + + for_each_valid_output_on_pipe(&data->display, pipe, output) + valid_tests++; + + igt_require_f(valid_tests, "no valid crtc/connector combinations found\n"); + } + + igt_subtest_f("pipe-%s", kmstest_pipe_name(pipe)) + for_each_valid_output_on_pipe(&data->display, pipe, output) + run_test(data, pipe, output); +} + +static int opt_handler(int option, int option_index, void *input) +{ + switch (option) { + case 'i': + opt.iterations = strtol(optarg, NULL, 0); + + if (opt.iterations < LOOP_FOREVER || opt.iterations == 0) { + igt_info("incorrect number of iterations\n"); + igt_assert(false); + } + + break; + case 's': + opt.user_seed = true; + opt.seed = strtol(optarg, NULL, 0); + break; + default: + igt_assert(false); + } + + return 0; +} + +const char *help_str = + " --iterations Number of iterations for test coverage. -1 loop forever, default 1 iteration\n" + " --seed Seed for random number generator\n"; + +static data_t data; + +int main(int argc, char *argv[]) +{ + struct option long_options[] = { + { "iterations", required_argument, NULL, 'i'}, + { "seed", required_argument, NULL, 's'}, + { 0, 0, 0, 0 } + }; + + igt_subtest_init_parse_opts(&argc, argv, "", long_options, help_str, + opt_handler, NULL); + + igt_skip_on_simulation(); + + igt_fixture { + data.drm_fd = drm_open_driver_master(DRIVER_ANY); + kmstest_set_vt_graphics_mode(); + igt_display_init(&data.display, data.drm_fd); + igt_require(data.display.n_pipes > 0); + igt_require(data.display.is_atomic); + } + + for (int pipe = 0; pipe < I915_MAX_PIPES; pipe++) { + igt_subtest_group + run_tests_for_pipe(&data, pipe); + } + + igt_fixture { + igt_display_fini(&data.display); + close(data.drm_fd); + } + + igt_exit(); +}