tests/gem_pwrite_pread.c

   1 /*
   2  * Copyright © 2011 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  *    Chris Wilson <chris@chris-wilson.co.uk>
  25  *
  26  */
  27
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <stdint.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <fcntl.h>
  34 #include <inttypes.h>
  35 #include <errno.h>
  36 #include <sys/stat.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/time.h>
  39 #include "drm.h"
  40 #include "i915_drm.h"
  41 #include "drmtest.h"
  42 #include "intel_bufmgr.h"
  43 #include "intel_batchbuffer.h"
  44 #include "intel_gpu_tools.h"
  45
  46 #define OBJECT_SIZE 16384
  47
  48 #define COPY_BLT_CMD            (2<<29|0x53<<22|0x6)
  49 #define BLT_WRITE_ALPHA         (1<<21)
  50 #define BLT_WRITE_RGB           (1<<20)
  51 #define BLT_SRC_TILED           (1<<15)
  52 #define BLT_DST_TILED           (1<<11)
  53
  54 static inline void build_batch(uint32_t *batch, int len, uint32_t *batch_len)
  55 {
  56         unsigned int i = 0;
  57
  58         batch[i++] = COPY_BLT_CMD | BLT_WRITE_ALPHA | BLT_WRITE_RGB;
  59         batch[i++] = 0xcc << 16 | 1 << 25 | 1 << 24 | len;
  60         batch[i++] = 0;
  61         batch[i++] = 1 << 16 | (len / 4);
  62         batch[i++] = 0; /* dst */
  63         batch[i++] = 0;
  64         batch[i++] = len;
  65         batch[i++] = 0; /* src */
  66         batch[i++] = MI_BATCH_BUFFER_END;
  67         batch[i++] = 0;
  68
  69         *batch_len = i * 4;
  70 }
  71
  72 #define GPP_BATCH_SIZE (10 * 4)
  73
  74 static void copy(int fd, uint32_t src, uint32_t dst, void *buf, int len, int loops)
  75 {
  76         uint32_t batch[GPP_BATCH_SIZE] = {0};
  77
  78         struct drm_i915_gem_relocation_entry reloc[] = {
  79                 { dst, 0, 4*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER },
  80                 { src, 0, 7*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, 0 },
  81         };
  82         struct drm_i915_gem_exec_object2 exec[] = {
  83                 { src },
  84                 { dst },
  85                 { gem_create(fd, 4096), 2, (uintptr_t)reloc }
  86         };
  87         struct drm_i915_gem_execbuffer2 execbuf = {
  88                 (uintptr_t)exec, 3,
  89                 0, 0,
  90                 0, 0, 0, 0,
  91                 HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0,
  92         };
  93
  94         build_batch(batch, len, &execbuf.batch_len);
  95
  96         gem_write(fd, exec[2].handle, 0, batch, execbuf.batch_len);
  97
  98         while (loops--) {
  99                 gem_write(fd, src, 0, buf, len);
 100                 do_or_die(drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf));
 101                 gem_read(fd, dst, 0, buf, len);
 102         }
 103
 104         gem_close(fd, exec[2].handle);
 105 }
 106
 107 static void as_gtt_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len, int loops)
 108 {
 109         uint32_t batch[GPP_BATCH_SIZE] = {0};
 110
 111         struct drm_i915_gem_relocation_entry reloc[] = {
 112                 { dst, 0, 4*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER },
 113                 { src, 0, 7*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, 0 },
 114         };
 115         struct drm_i915_gem_exec_object2 exec[] = {
 116                 { src },
 117                 { dst },
 118                 { gem_create(fd, 4096), 2, (uintptr_t)reloc }
 119         };
 120         struct drm_i915_gem_execbuffer2 execbuf = {
 121                 (uintptr_t)exec, 3,
 122                 0, GPP_BATCH_SIZE,
 123                 0, 0, 0, 0,
 124                 HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0,
 125         };
 126         uint32_t *src_ptr, *dst_ptr;
 127
 128         build_batch(batch, len, &execbuf.batch_len);
 129
 130         gem_write(fd, exec[2].handle, 0, batch, execbuf.batch_len);
 131
 132         src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
 133         dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
 134
 135         while (loops--) {
 136                 gem_set_domain(fd, src,
 137                                I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 138                 memcpy(src_ptr, buf, len);
 139
 140                 do_or_die(drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf));
 141                 gem_set_domain(fd, dst,
 142                                I915_GEM_DOMAIN_GTT, 0);
 143                 memcpy(buf, dst_ptr, len);
 144         }
 145
 146         munmap(dst_ptr, len);
 147         munmap(src_ptr, len);
 148         gem_close(fd, exec[2].handle);
 149 }
 150
 151
 152 static void as_cpu_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len, int loops)
 153 {
 154         uint32_t batch[GPP_BATCH_SIZE] = {0};
 155
 156         struct drm_i915_gem_relocation_entry reloc[] = {
 157                 { dst, 0, 4*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER },
 158                 { src, 0, 7*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, 0 },
 159         };
 160         struct drm_i915_gem_exec_object2 exec[] = {
 161                 { src },
 162                 { dst },
 163                 { gem_create(fd, 4096), 2, (uintptr_t)reloc }
 164         };
 165         struct drm_i915_gem_execbuffer2 execbuf = {
 166                 (uintptr_t)exec, 3,
 167                 0, GPP_BATCH_SIZE,
 168                 0, 0, 0, 0,
 169                 HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0,
 170         };
 171         uint32_t *src_ptr, *dst_ptr;
 172
 173         build_batch(batch, len, &execbuf.batch_len);
 174
 175         gem_write(fd, exec[2].handle, 0, batch, execbuf.batch_len);
 176
 177         src_ptr = gem_mmap__cpu(fd, src, OBJECT_SIZE, PROT_WRITE);
 178         dst_ptr = gem_mmap__cpu(fd, dst, OBJECT_SIZE, PROT_READ);
 179
 180         while (loops--) {
 181                 gem_set_domain(fd, src,
 182                                I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 183                 memcpy(src_ptr, buf, len);
 184
 185                 do_or_die(drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf));
 186                 gem_set_domain(fd, dst,
 187                                I915_GEM_DOMAIN_CPU, 0);
 188                 memcpy(buf, dst_ptr, len);
 189         }
 190
 191         munmap(dst_ptr, len);
 192         munmap(src_ptr, len);
 193         gem_close(fd, exec[2].handle);
 194 }
 195
 196 static void test_copy(int fd, uint32_t src, uint32_t dst, uint32_t *buf, int len)
 197 {
 198         uint32_t batch[GPP_BATCH_SIZE] = {0};
 199
 200         struct drm_i915_gem_relocation_entry reloc[] = {
 201                 { dst, 0, 4*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER },
 202                 { src, 0, 7*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, 0 },
 203         };
 204         struct drm_i915_gem_exec_object2 exec[] = {
 205                 { src },
 206                 { dst },
 207                 { gem_create(fd, 4096), 2, (uintptr_t)reloc }
 208         };
 209         struct drm_i915_gem_execbuffer2 execbuf = {
 210                 (uintptr_t)exec, 3,
 211                 0, GPP_BATCH_SIZE,
 212                 0, 0, 0, 0,
 213                 HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0,
 214         };
 215         int i;
 216
 217         build_batch(batch, len, &execbuf.batch_len);
 218
 219         gem_write(fd, exec[2].handle, 0, batch, execbuf.batch_len);
 220
 221         for (i = 0; i < len/4; i++)
 222                 buf[i] = i;
 223
 224         gem_write(fd, src, 0, buf, len);
 225         memset(buf, 0, len);
 226
 227         do_or_die(drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf));
 228         gem_read(fd, dst, 0, buf, len);
 229
 230         gem_close(fd, exec[2].handle);
 231
 232         for (i = 0; i < len/4; i++)
 233                 igt_assert(buf[i] == i);
 234 }
 235
 236 static void test_as_gtt_mmap(int fd, uint32_t src, uint32_t dst, int len)
 237 {
 238         uint32_t batch[GPP_BATCH_SIZE] = {0};
 239
 240         struct drm_i915_gem_relocation_entry reloc[] = {
 241                 { dst, 0, 4*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER },
 242                 { src, 0, 7*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, 0 },
 243         };
 244         struct drm_i915_gem_exec_object2 exec[] = {
 245                 { src },
 246                 { dst },
 247                 { gem_create(fd, 4096), 2, (uintptr_t)reloc }
 248         };
 249         struct drm_i915_gem_execbuffer2 execbuf = {
 250                 (uintptr_t)exec, 3,
 251                 0, GPP_BATCH_SIZE,
 252                 0, 0, 0, 0,
 253                 HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0,
 254         };
 255         uint32_t *src_ptr, *dst_ptr;
 256         int i;
 257
 258         build_batch(batch, len, &execbuf.batch_len);
 259
 260         gem_write(fd, exec[2].handle, 0, batch, execbuf.batch_len);
 261
 262         src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
 263         dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
 264
 265         gem_set_domain(fd, src, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 266         for (i = 0; i < len/4; i++)
 267                 src_ptr[i] = i;
 268
 269         do_or_die(drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf));
 270         gem_close(fd, exec[2].handle);
 271
 272         gem_set_domain(fd, dst, I915_GEM_DOMAIN_GTT, 0);
 273         for (i = 0; i < len/4; i++)
 274                 igt_assert(dst_ptr[i] == i);
 275
 276         munmap(dst_ptr, len);
 277         munmap(src_ptr, len);
 278 }
 279
 280 static void test_as_cpu_mmap(int fd, uint32_t src, uint32_t dst, int len)
 281 {
 282         uint32_t batch[GPP_BATCH_SIZE] = {0};
 283
 284         struct drm_i915_gem_relocation_entry reloc[] = {
 285                 { dst, 0, 4*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER },
 286                 { src, 0, 7*sizeof(uint32_t), 0, I915_GEM_DOMAIN_RENDER, 0 },
 287         };
 288         struct drm_i915_gem_exec_object2 exec[] = {
 289                 { src },
 290                 { dst },
 291                 { gem_create(fd, 4096), 2, (uintptr_t)reloc }
 292         };
 293         struct drm_i915_gem_execbuffer2 execbuf = {
 294                 (uintptr_t)exec, 3,
 295                 0, GPP_BATCH_SIZE,
 296                 0, 0, 0, 0,
 297                 HAS_BLT_RING(intel_get_drm_devid(fd)) ? I915_EXEC_BLT : 0,
 298         };
 299         uint32_t *src_ptr, *dst_ptr;
 300         int i;
 301
 302         build_batch(batch, len, &execbuf.batch_len);
 303
 304         gem_write(fd, exec[2].handle, 0, batch, execbuf.batch_len);
 305
 306         src_ptr = gem_mmap__cpu(fd, src, OBJECT_SIZE, PROT_WRITE);
 307         dst_ptr = gem_mmap__cpu(fd, dst, OBJECT_SIZE, PROT_READ);
 308
 309         gem_set_domain(fd, src, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 310         for (i = 0; i < len/4; i++)
 311                 src_ptr[i] = i;
 312
 313         do_or_die(drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf));
 314         gem_close(fd, exec[2].handle);
 315
 316         gem_set_domain(fd, dst, I915_GEM_DOMAIN_CPU, 0);
 317         for (i = 0; i < len/4; i++)
 318                 igt_assert(dst_ptr[i] == i);
 319
 320         munmap(dst_ptr, len);
 321         munmap(src_ptr, len);
 322 }
 323
 324 static double elapsed(const struct timeval *start,
 325                       const struct timeval *end,
 326                       int loop)
 327 {
 328         return (1e6*(end->tv_sec - start->tv_sec) + (end->tv_usec - start->tv_usec))/loop;
 329 }
 330
 331 static const char *bytes_per_sec(char *buf, double v)
 332 {
 333         const char *order[] = {
 334                 "",
 335                 "KiB",
 336                 "MiB",
 337                 "GiB",
 338                 "TiB",
 339                 NULL,
 340         }, **o = order;
 341
 342         while (v > 1000 && o[1]) {
 343                 v /= 1000;
 344                 o++;
 345         }
 346         sprintf(buf, "%.1f%s/s", v, *o);
 347         return buf;
 348 }
 349
 350 uint32_t *tmp, src, dst;
 351 int fd;
 352
 353 int main(int argc, char **argv)
 354 {
 355         int object_size = 0;
 356         uint32_t buf[20];
 357         int count;
 358
 359         igt_subtest_init(argc, argv);
 360         igt_skip_on_simulation();
 361
 362         if (argc > 1)
 363                 object_size = atoi(argv[1]);
 364         if (object_size == 0)
 365                 object_size = OBJECT_SIZE;
 366         object_size = (object_size + 3) & -4;
 367
 368         igt_fixture {
 369                 fd = drm_open_any();
 370
 371                 dst = gem_create(fd, object_size);
 372                 src = gem_create(fd, object_size);
 373                 tmp = malloc(object_size);
 374
 375                 gem_set_caching(fd, src, 0);
 376                 gem_set_caching(fd, dst, 0);
 377         }
 378
 379         igt_subtest("uncached-copy-correctness")
 380                 test_copy(fd, src, dst, tmp, object_size);
 381         igt_subtest("uncached-copy-performance") {
 382                 for (count = 1; count <= 1<<17; count <<= 1) {
 383                         struct timeval start, end;
 384
 385                         gettimeofday(&start, NULL);
 386                         copy(fd, src, dst, tmp, object_size, count);
 387                         gettimeofday(&end, NULL);
 388                         printf("Time to uncached copy %d bytes x %6d:   %7.3fµs, %s\n",
 389                                object_size, count,
 390                                elapsed(&start, &end, count),
 391                                bytes_per_sec((char *)buf, object_size/elapsed(&start, &end, count)*1e6));
 392                         fflush(stdout);
 393                 }
 394         }
 395
 396         igt_subtest("uncached-pwrite-blt-gtt_mmap-correctness")
 397                 test_as_gtt_mmap(fd, src, dst, object_size);
 398         igt_subtest("uncached-pwrite-blt-gtt_mmap-performance") {
 399                 for (count = 1; count <= 1<<17; count <<= 1) {
 400                         struct timeval start, end;
 401
 402                         gettimeofday(&start, NULL);
 403                         as_gtt_mmap(fd, src, dst, tmp, object_size, count);
 404                         gettimeofday(&end, NULL);
 405                         printf("** mmap uncached copy %d bytes x %6d:   %7.3fµs, %s\n",
 406                                object_size, count,
 407                                elapsed(&start, &end, count),
 408                                bytes_per_sec((char *)buf, object_size/elapsed(&start, &end, count)*1e6));
 409                         fflush(stdout);
 410                 }
 411         }
 412
 413         igt_fixture {
 414                 gem_set_caching(fd, src, 1);
 415                 gem_set_caching(fd, dst, 1);
 416         }
 417
 418         igt_subtest("snooped-copy-correctness")
 419                 test_copy(fd, src, dst, tmp, object_size);
 420         igt_subtest("snooped-copy-performance") {
 421                 for (count = 1; count <= 1<<17; count <<= 1) {
 422                         struct timeval start, end;
 423
 424                         gettimeofday(&start, NULL);
 425                         copy(fd, src, dst, tmp, object_size, count);
 426                         gettimeofday(&end, NULL);
 427                         printf("Time to snooped copy %d bytes x %6d:    %7.3fµs, %s\n",
 428                                object_size, count,
 429                                elapsed(&start, &end, count),
 430                                bytes_per_sec((char *)buf, object_size/elapsed(&start, &end, count)*1e6));
 431                         fflush(stdout);
 432                 }
 433         }
 434
 435         igt_subtest("snooped-pwrite-blt-cpu_mmap-correctness")
 436                 test_as_cpu_mmap(fd, src, dst, object_size);
 437         igt_subtest("snooped-pwrite-blt-cpu_mmap-performance") {
 438                 for (count = 1; count <= 1<<17; count <<= 1) {
 439                         struct timeval start, end;
 440
 441                         gettimeofday(&start, NULL);
 442                         as_cpu_mmap(fd, src, dst, tmp, object_size, count);
 443                         gettimeofday(&end, NULL);
 444                         printf("** mmap snooped copy %d bytes x %6d:    %7.3fµs, %s\n",
 445                                object_size, count,
 446                                elapsed(&start, &end, count),
 447                                bytes_per_sec((char *)buf, object_size/elapsed(&start, &end, count)*1e6));
 448                         fflush(stdout);
 449                 }
 450         }
 451
 452         igt_fixture {
 453                 gem_set_caching(fd, src, 2);
 454                 gem_set_caching(fd, dst, 2);
 455         }
 456
 457         igt_subtest("display-copy-correctness")
 458                 test_copy(fd, src, dst, tmp, object_size);
 459         igt_subtest("display-copy-performance") {
 460                 for (count = 1; count <= 1<<17; count <<= 1) {
 461                         struct timeval start, end;
 462
 463                         gettimeofday(&start, NULL);
 464                         copy(fd, src, dst, tmp, object_size, count);
 465                         gettimeofday(&end, NULL);
 466                         printf("Time to display copy %d bytes x %6d:    %7.3fµs, %s\n",
 467                                object_size, count,
 468                                elapsed(&start, &end, count),
 469                                bytes_per_sec((char *)buf, object_size/elapsed(&start, &end, count)*1e6));
 470                         fflush(stdout);
 471                 }
 472         }
 473
 474         igt_subtest("display-pwrite-blt-gtt_mmap-correctness")
 475                 test_as_gtt_mmap(fd, src, dst, object_size);
 476         igt_subtest("display-pwrite-blt-gtt_mmap-performance") {
 477                 for (count = 1; count <= 1<<17; count <<= 1) {
 478                         struct timeval start, end;
 479
 480                         gettimeofday(&start, NULL);
 481                         as_gtt_mmap(fd, src, dst, tmp, object_size, count);
 482                         gettimeofday(&end, NULL);
 483                         printf("** mmap display copy %d bytes x %6d:    %7.3fµs, %s\n",
 484                                object_size, count,
 485                                elapsed(&start, &end, count),
 486                                bytes_per_sec((char *)buf, object_size/elapsed(&start, &end, count)*1e6));
 487                         fflush(stdout);
 488                 }
 489         }
 490
 491         igt_fixture {
 492                 free(tmp);
 493                 gem_close(fd, src);
 494                 gem_close(fd, dst);
 495
 496                 close(fd);
 497         }
 498
 499         igt_exit();
 500 }