tests/gem_seqno_wrap.c

   1 /*
   2  * Copyright (c) 2012 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Mika Kuoppala <mika.kuoppala@intel.com>
  25  *
  26  */
  27
  28 /*
  29  * This test runs blitcopy -> rendercopy with multiple buffers over wrap
  30  * boundary.
  31  */
  32
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <time.h>
  36 #include <assert.h>
  37 #include <fcntl.h>
  38 #include <unistd.h>
  39 #include <sys/types.h>
  40 #include <sys/wait.h>
  41 #include <limits.h>
  42 #include <wordexp.h>
  43 #include <signal.h>
  44
  45 #include "i915_drm.h"
  46 #include "intel_bufmgr.h"
  47 #include "intel_batchbuffer.h"
  48 #include "intel_gpu_tools.h"
  49 #include "rendercopy.h"
  50
  51 static int devid;
  52 static int card_index = 0;
  53 static uint32_t last_seqno = 0;
  54
  55 static struct intel_batchbuffer *batch_blt;
  56 static struct intel_batchbuffer *batch_3d;
  57
  58 struct option_struct {
  59         int rounds;
  60         int background;
  61         char cmd[1024];
  62         int verbose;
  63         int timeout;
  64         int dontwrap;
  65         int prewrap_space;
  66         int random;
  67         int buffers;
  68 };
  69
  70 static struct option_struct options;
  71
  72 static void init_buffer(drm_intel_bufmgr *bufmgr,
  73                         struct scratch_buf *buf,
  74                         drm_intel_bo *bo,
  75                         int width, int height)
  76 {
  77         /* buf->bo = drm_intel_bo_alloc(bufmgr, "", size, 4096); */
  78         buf->bo = bo;
  79         buf->size = width * height * 4;
  80         assert(buf->bo);
  81         buf->tiling = I915_TILING_NONE;
  82         buf->data = buf->cpu_mapping = NULL;
  83         buf->num_tiles = width * height * 4;
  84         buf->stride = width * 4;
  85 }
  86
  87 static void
  88 set_bo(drm_intel_bo *bo, uint32_t val, int width, int height)
  89 {
  90         int size = width * height;
  91         uint32_t *vaddr;
  92
  93         drm_intel_gem_bo_start_gtt_access(bo, true);
  94         vaddr = bo->virtual;
  95         while (size--)
  96                 *vaddr++ = val;
  97 }
  98
  99 static int
 100 cmp_bo(drm_intel_bo *bo, uint32_t val, int width, int height)
 101 {
 102         int size = width * height;
 103         uint32_t *vaddr;
 104
 105         drm_intel_gem_bo_start_gtt_access(bo, false);
 106         vaddr = bo->virtual;
 107         while (size--) {
 108                 if (*vaddr++ != val) {
 109                         printf("%d: 0x%x differs from assumed 0x%x\n",
 110                                width * height - size, *vaddr-1, val);
 111                         return -1;
 112                 }
 113         }
 114
 115         return 0;
 116 }
 117
 118 static drm_intel_bo *
 119 create_bo(drm_intel_bufmgr *bufmgr, uint32_t val, int width, int height)
 120 {
 121         drm_intel_bo *bo;
 122
 123         bo = drm_intel_bo_alloc(bufmgr, "bo", width * height * 4, 0);
 124         assert(bo);
 125
 126         /* gtt map doesn't have a write parameter, so just keep the mapping
 127          * around (to avoid the set_domain with the gtt write domain set) and
 128          * manually tell the kernel when we start access the gtt. */
 129         drm_intel_gem_bo_map_gtt(bo);
 130
 131         set_bo(bo, val, width, height);
 132
 133         return bo;
 134 }
 135
 136 static void release_bo(drm_intel_bo *bo)
 137 {
 138         drm_intel_gem_bo_unmap_gtt(bo);
 139         drm_intel_bo_unreference(bo);
 140 }
 141
 142 static void render_copyfunc(struct scratch_buf *src,
 143                             struct scratch_buf *dst,
 144                             int width,
 145                             int height)
 146 {
 147         const int src_x = 0, src_y = 0, dst_x = 0, dst_y = 0;
 148         render_copyfunc_t rendercopy = get_render_copyfunc(devid);
 149         static int warned = 0;
 150
 151         if (rendercopy) {
 152                 rendercopy(batch_3d,
 153                            src, src_x, src_y,
 154                            width, height,
 155                            dst, dst_x, dst_y);
 156                 intel_batchbuffer_flush(batch_3d);
 157         } else {
 158                 if (!warned) {
 159                         printf("No render copy found for this gen, "
 160                                "test is shallow!\n");
 161                         warned = 1;
 162                 }
 163                 assert(dst->bo);
 164                 assert(src->bo);
 165                 intel_copy_bo(batch_blt, dst->bo, src->bo, width, height);
 166                 intel_batchbuffer_flush(batch_blt);
 167         }
 168 }
 169
 170 static void exchange_uint(void *array, unsigned i, unsigned j)
 171 {
 172         unsigned *i_arr = array;
 173         unsigned i_tmp;
 174
 175         i_tmp = i_arr[i];
 176         i_arr[i] = i_arr[j];
 177         i_arr[j] = i_tmp;
 178 }
 179
 180 static int run_sync_test(int num_buffers, bool verify)
 181 {
 182         drm_intel_bufmgr *bufmgr;
 183         int max;
 184         drm_intel_bo **src, **dst1, **dst2;
 185         int width = 128, height = 128;
 186         int fd;
 187         int i;
 188         int r = -1;
 189         int failed = 0;
 190         unsigned int *p_dst1, *p_dst2;
 191         struct scratch_buf *s_src, *s_dst;
 192
 193         fd = drm_open_any();
 194         assert(fd >= 0);
 195
 196         gem_quiescent_gpu(fd);
 197
 198         devid = intel_get_drm_devid(fd);
 199
 200         max = gem_aperture_size (fd) / (1024 * 1024) / 2;
 201         if (num_buffers > max)
 202                 num_buffers = max;
 203
 204         bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
 205         drm_intel_bufmgr_gem_enable_reuse(bufmgr);
 206         batch_blt = intel_batchbuffer_alloc(bufmgr, intel_get_drm_devid(fd));
 207         assert(batch_blt);
 208         batch_3d = intel_batchbuffer_alloc(bufmgr, intel_get_drm_devid(fd));
 209         assert(batch_3d);
 210
 211         src = malloc(num_buffers * sizeof(**src));
 212         assert(src);
 213
 214         dst1 = malloc(num_buffers * sizeof(**dst1));
 215         assert(dst1);
 216
 217         dst2 = malloc(num_buffers * sizeof(**dst2));
 218         assert(dst2);
 219
 220         s_src = malloc(num_buffers * sizeof(*s_src));
 221         assert(s_src);
 222
 223         s_dst = malloc(num_buffers * sizeof(*s_dst));
 224         assert(s_dst);
 225
 226         p_dst1 = malloc(num_buffers * sizeof(unsigned int));
 227         if (p_dst1 == NULL)
 228                 return -ENOMEM;
 229
 230         p_dst2 = malloc(num_buffers * sizeof(unsigned int));
 231         if (p_dst2 == NULL)
 232                 return -ENOMEM;
 233
 234         for (i = 0; i < num_buffers; i++) {
 235                 p_dst1[i] = p_dst2[i] = i;
 236                 src[i] = create_bo(bufmgr, i, width, height);
 237                 assert(src[i]);
 238                 dst1[i] = create_bo(bufmgr, ~i, width, height);
 239                 assert(dst1[i]);
 240                 dst2[i] = create_bo(bufmgr, ~i, width, height);
 241                 assert(dst2[i]);
 242                 init_buffer(bufmgr, &s_src[i], src[i], width, height);
 243                 init_buffer(bufmgr, &s_dst[i], dst1[i], width, height);
 244         }
 245
 246         drmtest_permute_array(p_dst1, num_buffers, exchange_uint);
 247         drmtest_permute_array(p_dst2, num_buffers, exchange_uint);
 248
 249         for (i = 0; i < num_buffers; i++)
 250                 render_copyfunc(&s_src[i], &s_dst[p_dst1[i]], width, height);
 251
 252         /* Only sync between buffers if this is actual test run and
 253          * not a seqno filler */
 254         if (verify) {
 255                 for (i = 0; i < num_buffers; i++)
 256                         intel_copy_bo(batch_blt, dst2[p_dst2[i]], dst1[p_dst1[i]],
 257                                       width, height);
 258
 259                 for (i = 0; i < num_buffers; i++) {
 260                         r = cmp_bo(dst2[p_dst2[i]], i, width, height);
 261                         if (r) {
 262                                 printf("buffer %d differs, seqno_before_test 0x%x, "
 263                                        " approximated seqno on test fail 0x%x\n",
 264                                        i, last_seqno, last_seqno + i * 2);
 265                                 failed = -1;
 266                         }
 267                 }
 268         }
 269
 270         for (i = 0; i < num_buffers; i++) {
 271                 release_bo(src[i]);
 272                 release_bo(dst1[i]);
 273                 release_bo(dst2[i]);
 274         }
 275
 276         intel_batchbuffer_free(batch_3d);
 277         intel_batchbuffer_free(batch_blt);
 278         drm_intel_bufmgr_destroy(bufmgr);
 279
 280         free(p_dst1);
 281         free(p_dst2);
 282         free(s_dst);
 283         free(s_src);
 284         free(dst2);
 285         free(dst1);
 286         free(src);
 287
 288         gem_quiescent_gpu(fd);
 289
 290         close(fd);
 291
 292         return failed;
 293 }
 294
 295 static int run_cmd(char *s)
 296 {
 297         int pid;
 298         int r = -1;
 299         int status = 0;
 300         wordexp_t wexp;
 301         int i;
 302         r = wordexp(s, &wexp, 0);
 303         if (r != 0) {
 304                 printf("can't parse %s\n", s);
 305                 return r;
 306         }
 307
 308         for(i = 0; i < wexp.we_wordc; i++)
 309                 printf("argv[%d] = %s\n", i, wexp.we_wordv[i]);
 310
 311         pid = fork();
 312
 313         if (pid == 0) {
 314                 char path[PATH_MAX];
 315                 char full_path[PATH_MAX];
 316
 317                 if (getcwd(path, PATH_MAX) == NULL)
 318                         perror("getcwd");
 319
 320                 assert(snprintf(full_path, PATH_MAX, "%s/%s", path, wexp.we_wordv[0]) > 0);
 321
 322                 /* if (!options.verbose) {
 323                         close(STDOUT_FILENO);
 324                         close(STDERR_FILENO);
 325                 }
 326                 */
 327
 328                 r = execv(full_path, wexp.we_wordv);
 329                 if (r == -1)
 330                         perror("execv failed");
 331         } else {
 332                 int waitcount = options.timeout;
 333
 334                 while(waitcount-- > 0) {
 335                         r = waitpid(pid, &status, WNOHANG);
 336                         if (r == pid) {
 337                                 if(WIFEXITED(status)) {
 338                                         if (WEXITSTATUS(status))
 339                                                 fprintf(stderr,
 340                                                     "child returned with %d\n",
 341                                                         WEXITSTATUS(status));
 342                                         return WEXITSTATUS(status);
 343                                 }
 344                         } else if (r != 0) {
 345                                 perror("waitpid");
 346                                 return -errno;
 347                         }
 348
 349                         sleep(3);
 350                 }
 351
 352                 kill(pid, SIGKILL);
 353                 return -ETIMEDOUT;
 354         }
 355
 356         return r;
 357 }
 358
 359 static const char *dfs_base = "/sys/kernel/debug/dri";
 360 static const char *dfs_entry = "i915_next_seqno";
 361
 362 static int dfs_open(int mode)
 363 {
 364         char fname[FILENAME_MAX];
 365         int fh;
 366
 367         snprintf(fname, FILENAME_MAX, "%s/%i/%s",
 368                  dfs_base, card_index, dfs_entry);
 369
 370         fh = open(fname, mode);
 371         if (fh == -1) {
 372                 fprintf(stderr,
 373                         "error %d opening '%s/%d/%s'. too old kernel?\n",
 374                         errno, dfs_base, card_index, dfs_entry);
 375                 exit(77);
 376         }
 377
 378         return fh;
 379 }
 380
 381 static int __read_seqno(uint32_t *seqno)
 382 {
 383         int fh;
 384         char buf[32];
 385         int r;
 386         char *p;
 387         unsigned long int tmp;
 388
 389         fh = dfs_open(O_RDONLY);
 390
 391         r = read(fh, buf, sizeof(buf) - 1);
 392         close(fh);
 393         if (r < 0) {
 394                 perror("read");
 395                 return -errno;
 396         }
 397
 398         buf[r] = 0;
 399
 400         p = strstr(buf, "0x");
 401         if (!p)
 402                 p = buf;
 403
 404         errno = 0;
 405         tmp = strtoul(p, NULL, 0);
 406         if (tmp == ULONG_MAX && errno) {
 407                 perror("strtoul");
 408                 return -errno;
 409         }
 410
 411         *seqno = tmp;
 412
 413         if (options.verbose)
 414                 printf("next_seqno: 0x%x\n", *seqno);
 415
 416         return 0;
 417 }
 418
 419 static int read_seqno(void)
 420 {
 421         uint32_t seqno = 0;
 422         int r;
 423         int wrap = 0;
 424
 425         r = __read_seqno(&seqno);
 426         assert(r == 0);
 427
 428         if (last_seqno > seqno)
 429                 wrap++;
 430
 431         last_seqno = seqno;
 432
 433         return wrap;
 434 }
 435
 436 static int write_seqno(uint32_t seqno)
 437 {
 438         int fh;
 439         char buf[32];
 440         int r;
 441
 442         if (options.dontwrap)
 443                 return 0;
 444
 445         fh = dfs_open(O_RDWR);
 446         assert(snprintf(buf, sizeof(buf), "0x%x", seqno) > 0);
 447
 448         r = write(fh, buf, strnlen(buf, sizeof(buf)));
 449         close(fh);
 450         if (r < 0)
 451                 return r;
 452
 453         assert(r == strnlen(buf, sizeof(buf)));
 454
 455         last_seqno = seqno;
 456
 457         if (options.verbose)
 458                 printf("next_seqno set to: 0x%x\n", seqno);
 459
 460         return 0;
 461 }
 462
 463 static uint32_t calc_prewrap_val(void)
 464 {
 465         const int pval = options.prewrap_space;
 466
 467         if (options.random == 0)
 468                 return pval;
 469
 470         if (pval == 0)
 471                 return 0;
 472
 473         return (random() % pval);
 474 }
 475
 476 static int run_test(void)
 477 {
 478         int r;
 479
 480         if (strnlen(options.cmd, sizeof(options.cmd)) > 0) {
 481                 r = run_cmd(options.cmd);
 482         } else {
 483                 r = run_sync_test(options.buffers, true);
 484         }
 485
 486         return r;
 487 }
 488
 489 static void preset_run_once(void)
 490 {
 491         assert(write_seqno(1) == 0);
 492         assert(run_test() == 0);
 493
 494         assert(write_seqno(0x7fffffff) == 0);
 495         assert(run_test() == 0);
 496
 497         assert(write_seqno(0xffffffff) == 0);
 498         assert(run_test() == 0);
 499
 500         assert(write_seqno(0xfffffff0) == 0);
 501         assert(run_test() == 0);
 502 }
 503
 504 static void random_run_once(void)
 505 {
 506         uint32_t val;
 507
 508         do {
 509                 val = random() % UINT32_MAX;
 510                 if (RAND_MAX < UINT32_MAX)
 511                         val += random();
 512         } while (val == 0);
 513
 514         assert(write_seqno(val) == 0);
 515         assert(run_test() == 0);
 516 }
 517
 518 static void wrap_run_once(void)
 519 {
 520         const uint32_t pw_val = calc_prewrap_val();
 521
 522         assert(write_seqno(UINT32_MAX - pw_val) == 0);
 523
 524         while(!read_seqno())
 525                 assert(run_test() == 0);
 526 }
 527
 528 static void background_run_once(void)
 529 {
 530         const uint32_t pw_val = calc_prewrap_val();
 531
 532         assert(write_seqno(UINT32_MAX - pw_val) == 0);
 533
 534         while(!read_seqno())
 535                 sleep(3);
 536 }
 537
 538 static void print_usage(const char *s)
 539 {
 540         printf("%s: [OPTION]...\n", s);
 541         printf("    where options are:\n");
 542         printf("    -b --background       run in background inducing wraps\n");
 543         printf("    -c --cmd=cmdstring    use cmdstring to cross wrap\n");
 544         printf("    -n --rounds=num       run num times across wrap boundary, 0 == forever\n");
 545         printf("    -t --timeout=sec      set timeout to wait for testrun to sec seconds\n");
 546         printf("    -d --dontwrap         don't wrap just run the test\n");
 547         printf("    -p --prewrap=n        set seqno to WRAP - n for each testrun\n");
 548         printf("    -r --norandom         dont randomize prewrap space\n");
 549         printf("    -i --buffers          number of buffers to copy\n");
 550         exit(-1);
 551 }
 552
 553 static void parse_options(int argc, char **argv)
 554 {
 555         int c;
 556         int option_index = 0;
 557         static struct option long_options[] = {
 558                 {"cmd", required_argument, 0, 'c'},
 559                 {"rounds", required_argument, 0, 'n'},
 560                 {"background", no_argument, 0, 'b'},
 561                 {"timeout", required_argument, 0, 't'},
 562                 {"dontwrap", no_argument, 0, 'd'},
 563                 {"verbose", no_argument, 0, 'v'},
 564                 {"prewrap", required_argument, 0, 'p'},
 565                 {"norandom", no_argument, 0, 'r'},
 566                 {"buffers", required_argument, 0, 'i'},
 567         };
 568
 569         strcpy(options.cmd, "");
 570         options.rounds = 50;
 571         options.background = 0;
 572         options.dontwrap = 0;
 573         options.timeout = 20;
 574         options.verbose = 0;
 575         options.random = 1;
 576         options.prewrap_space = 21;
 577         options.buffers = 10;
 578
 579         while((c = getopt_long(argc, argv, "c:n:bvt:dp:ri:",
 580                                long_options, &option_index)) != -1) {
 581                 switch(c) {
 582                 case 'b':
 583                         options.background = 1;
 584                         printf("running in background inducing wraps\n");
 585                         break;
 586                 case 'd':
 587                         options.dontwrap = 1;
 588                         printf("won't wrap after testruns\n");
 589                         break;
 590                 case 'n':
 591                         options.rounds = atoi(optarg);
 592                         printf("running %d rounds\n", options.rounds);
 593                         break;
 594                 case 'c':
 595                         strncpy(options.cmd, optarg, sizeof(options.cmd) - 1);
 596                         options.cmd[sizeof(options.cmd) - 1] = 0;
 597                         printf("cmd set to %s\n", options.cmd);
 598                         break;
 599                 case 'i':
 600                         options.buffers = atoi(optarg);
 601                         printf("buffers %d\n", options.buffers);
 602                         break;
 603                 case 't':
 604                         options.timeout = atoi(optarg);
 605                         if (options.timeout == 0)
 606                                 options.timeout = 10;
 607                         printf("setting timeout to %d seconds\n",
 608                                options.timeout);
 609                         break;
 610                 case 'v':
 611                         options.verbose = 1;
 612                         break;
 613                 case 'r':
 614                         options.random = 0;
 615                         break;
 616                 case 'p':
 617                         options.prewrap_space = atoi(optarg);
 618                         printf("prewrap set to %d (0x%x)\n",
 619                                options.prewrap_space, UINT32_MAX -
 620                                options.prewrap_space);
 621                         break;
 622                 default:
 623                         printf("unkown command options\n");
 624                         print_usage(argv[0]);
 625                         break;
 626                 }
 627         }
 628
 629         if (optind < argc) {
 630                 printf("unkown command options\n");
 631                 print_usage(argv[0]);
 632         }
 633 }
 634
 635 int main(int argc, char **argv)
 636 {
 637         int wcount = 0;
 638         int r = -1;
 639
 640         parse_options(argc, argv);
 641
 642         card_index = drm_get_card(0);
 643         assert(card_index != -1);
 644
 645         srandom(time(NULL));
 646
 647         while(options.rounds == 0 || wcount < options.rounds) {
 648                 if (options.background) {
 649                         background_run_once();
 650                 } else {
 651                         preset_run_once();
 652                         random_run_once();
 653                         wrap_run_once();
 654                 }
 655
 656                 wcount++;
 657
 658                 if (options.verbose) {
 659                         printf("%s done: %d\n",
 660                                options.dontwrap ? "tests" : "wraps", wcount);
 661                         fflush(stdout);
 662                 }
 663         }
 664
 665         if (options.rounds == wcount) {
 666                 if (options.verbose)
 667                         printf("done %d wraps successfully\n", wcount);
 668                 return 0;
 669         }
 670
 671         return r;
 672 }