tests/pm_rps.c

   1 /*
   2  * Copyright © 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  *    Ben Widawsky <ben@bwidawsk.net>
  25  *    Jeff McGee <jeff.mcgee@intel.com>
  26  *
  27  */
  28
  29 #define _GNU_SOURCE
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <unistd.h>
  34 #include <getopt.h>
  35 #include "drmtest.h"
  36 #include "intel_gpu_tools.h"
  37 #include "intel_bufmgr.h"
  38 #include "intel_batchbuffer.h"
  39
  40 static bool verbose = false;
  41
  42 static int drm_fd;
  43
  44 static const char sysfs_base_path[] = "/sys/class/drm/card%d/gt_%s_freq_mhz";
  45 enum {
  46         CUR,
  47         MIN,
  48         MAX,
  49         RP0,
  50         RP1,
  51         RPn,
  52         NUMFREQ
  53 };
  54
  55 static int origfreqs[NUMFREQ];
  56
  57 struct junk {
  58         const char *name;
  59         const char *mode;
  60         FILE *filp;
  61 } stuff[] = {
  62         { "cur", "r", NULL }, { "min", "rb+", NULL }, { "max", "rb+", NULL }, { "RP0", "r", NULL }, { "RP1", "r", NULL }, { "RPn", "r", NULL }, { NULL, NULL, NULL }
  63 };
  64
  65 static int readval(FILE *filp)
  66 {
  67         int val;
  68         int scanned;
  69
  70         rewind(filp);
  71         scanned = fscanf(filp, "%d", &val);
  72         igt_assert(scanned == 1);
  73
  74         return val;
  75 }
  76
  77 static void read_freqs(int *freqs)
  78 {
  79         int i;
  80
  81         for (i = 0; i < NUMFREQ; i++)
  82                 freqs[i] = readval(stuff[i].filp);
  83 }
  84
  85 static int do_writeval(FILE *filp, int val, int lerrno)
  86 {
  87         int ret, orig;
  88
  89         orig = readval(filp);
  90         rewind(filp);
  91         ret = fprintf(filp, "%d", val);
  92
  93         if (lerrno) {
  94                 /* Expecting specific error */
  95                 igt_assert(ret == EOF && errno == lerrno);
  96                 igt_assert(readval(filp) == orig);
  97         } else {
  98                 /* Expecting no error */
  99                 igt_assert(ret != EOF);
 100                 igt_assert(readval(filp) == val);
 101         }
 102
 103         return ret;
 104 }
 105 #define writeval(filp, val) do_writeval(filp, val, 0)
 106 #define writeval_inval(filp, val) do_writeval(filp, val, EINVAL)
 107
 108 static void setfreq(int val)
 109 {
 110         if (val > readval(stuff[MAX].filp)) {
 111                 writeval(stuff[MAX].filp, val);
 112                 writeval(stuff[MIN].filp, val);
 113         } else {
 114                 writeval(stuff[MIN].filp, val);
 115                 writeval(stuff[MAX].filp, val);
 116         }
 117 }
 118
 119 static void checkit(const int *freqs)
 120 {
 121         igt_assert(freqs[MIN] <= freqs[MAX]);
 122         igt_assert(freqs[CUR] <= freqs[MAX]);
 123         igt_assert(freqs[MIN] <= freqs[CUR]);
 124         igt_assert(freqs[RPn] <= freqs[MIN]);
 125         igt_assert(freqs[MAX] <= freqs[RP0]);
 126         igt_assert(freqs[RP1] <= freqs[RP0]);
 127         igt_assert(freqs[RPn] <= freqs[RP1]);
 128         igt_assert(freqs[RP0] != 0);
 129         igt_assert(freqs[RP1] != 0);
 130 }
 131
 132 static void dumpit(const int *freqs)
 133 {
 134         int i;
 135
 136         printf("gt freq (MHz):");
 137         for (i = 0; i < NUMFREQ; i++)
 138                 printf("  %s=%d", stuff[i].name, freqs[i]);
 139
 140         printf("\n");
 141 }
 142 #define dump(x) if (verbose) dumpit(x)
 143 #define log(...) if (verbose) printf(__VA_ARGS__)
 144
 145 static struct load_helper {
 146         int devid;
 147         int has_ppgtt;
 148         drm_intel_bufmgr *bufmgr;
 149         struct intel_batchbuffer *batch;
 150         drm_intel_bo *target_buffer;
 151         bool ready;
 152         bool exit;
 153         struct igt_helper_process igt_proc;
 154 } lh;
 155
 156 static void load_helper_signal_handler(int sig)
 157 {
 158         lh.exit = true;
 159 }
 160
 161 static void emit_store_dword_imm(uint32_t val)
 162 {
 163         int cmd;
 164         struct intel_batchbuffer *batch = lh.batch;
 165
 166         cmd = MI_STORE_DWORD_IMM;
 167         if (!lh.has_ppgtt)
 168                 cmd |= MI_MEM_VIRTUAL;
 169
 170         if (intel_gen(lh.devid) >= 8) {
 171                 BEGIN_BATCH(4);
 172                 OUT_BATCH(cmd);
 173                 OUT_RELOC(lh.target_buffer, I915_GEM_DOMAIN_INSTRUCTION,
 174                           I915_GEM_DOMAIN_INSTRUCTION, 0);
 175                 OUT_BATCH(0);
 176                 OUT_BATCH(val);
 177                 ADVANCE_BATCH();
 178         } else {
 179                 BEGIN_BATCH(4);
 180                 OUT_BATCH(cmd);
 181                 OUT_BATCH(0); /* reserved */
 182                 OUT_RELOC(lh.target_buffer, I915_GEM_DOMAIN_INSTRUCTION,
 183                           I915_GEM_DOMAIN_INSTRUCTION, 0);
 184                 OUT_BATCH(val);
 185                 ADVANCE_BATCH();
 186         }
 187 }
 188
 189 static void load_helper_run(void)
 190 {
 191         assert(!lh.igt_proc.running);
 192
 193         igt_require(lh.ready == true);
 194
 195         igt_fork_helper(&lh.igt_proc) {
 196                 uint32_t val = 0;
 197
 198                 signal(SIGUSR1, load_helper_signal_handler);
 199
 200                 while (!lh.exit) {
 201                         emit_store_dword_imm(val);
 202                         intel_batchbuffer_flush_on_ring(lh.batch, 0);
 203                         val++;
 204                 }
 205
 206                 log("load helper sent %u dword writes\n", val);
 207         }
 208 }
 209
 210 static void load_helper_stop(void)
 211 {
 212         assert(lh.igt_proc.running);
 213         kill(lh.igt_proc.pid, SIGUSR1);
 214         igt_wait_helper(&lh.igt_proc);
 215 }
 216
 217 /* The load helper resource is used by only some subtests. We attempt to
 218  * initialize in igt_fixture but do our igt_require check only if a
 219  * subtest attempts to run it */
 220 static void load_helper_init(void)
 221 {
 222         lh.devid = intel_get_drm_devid(drm_fd);
 223         lh.has_ppgtt = gem_uses_aliasing_ppgtt(drm_fd);
 224
 225         /* MI_STORE_DATA can only use GTT address on gen4+/g33 and needs
 226          * snoopable mem on pre-gen6. */
 227         if (intel_gen(lh.devid) < 6) {
 228                 log("load helper init failed: pre-gen6 not supported\n");
 229                 return;
 230         }
 231
 232         lh.bufmgr = drm_intel_bufmgr_gem_init(drm_fd, 4096);
 233         if (!lh.bufmgr) {
 234                 log("load helper init failed: buffer manager init\n");
 235                 return;
 236         }
 237         drm_intel_bufmgr_gem_enable_reuse(lh.bufmgr);
 238
 239         lh.batch = intel_batchbuffer_alloc(lh.bufmgr, lh.devid);
 240         if (!lh.batch) {
 241                 log("load helper init failed: batch buffer alloc\n");
 242                 return;
 243         }
 244
 245         lh.target_buffer = drm_intel_bo_alloc(lh.bufmgr, "target bo",
 246                                               4096, 4096);
 247         if (!lh.target_buffer) {
 248                 log("load helper init failed: target buffer alloc\n");
 249                 return;
 250         }
 251
 252         lh.ready = true;
 253 }
 254
 255 static void load_helper_deinit(void)
 256 {
 257         if (lh.igt_proc.running)
 258                 load_helper_stop();
 259
 260         if (lh.target_buffer)
 261                 drm_intel_bo_unreference(lh.target_buffer);
 262
 263         if (lh.batch)
 264                 intel_batchbuffer_free(lh.batch);
 265
 266         if (lh.bufmgr)
 267                 drm_intel_bufmgr_destroy(lh.bufmgr);
 268 }
 269
 270 static void min_max_config(void (*check)(void))
 271 {
 272         int fmid = (origfreqs[RPn] + origfreqs[RP0]) / 2;
 273
 274         log("\nCheck original min and max...\n");
 275         check();
 276
 277         log("\nSet min=RPn and max=RP0...\n");
 278         writeval(stuff[MIN].filp, origfreqs[RPn]);
 279         writeval(stuff[MAX].filp, origfreqs[RP0]);
 280         check();
 281
 282         log("\nIncrease min to midpoint...\n");
 283         writeval(stuff[MIN].filp, fmid);
 284         check();
 285
 286         log("\nIncrease min to RP0...\n");
 287         writeval(stuff[MIN].filp, origfreqs[RP0]);
 288         check();
 289
 290         log("\nIncrease min above RP0 (invalid)...\n");
 291         writeval_inval(stuff[MIN].filp, origfreqs[RP0] + 1000);
 292         check();
 293
 294         log("\nDecrease max to RPn (invalid)...\n");
 295         writeval_inval(stuff[MAX].filp, origfreqs[RPn]);
 296         check();
 297
 298         log("\nDecrease min to midpoint...\n");
 299         writeval(stuff[MIN].filp, fmid);
 300         check();
 301
 302         log("\nDecrease min to RPn...\n");
 303         writeval(stuff[MIN].filp, origfreqs[RPn]);
 304         check();
 305
 306         log("\nDecrease min below RPn (invalid)...\n");
 307         writeval_inval(stuff[MIN].filp, 0);
 308         check();
 309
 310         log("\nDecrease max to midpoint...\n");
 311         writeval(stuff[MAX].filp, fmid);
 312         check();
 313
 314         log("\nDecrease max to RPn...\n");
 315         writeval(stuff[MAX].filp, origfreqs[RPn]);
 316         check();
 317
 318         log("\nDecrease max below RPn (invalid)...\n");
 319         writeval_inval(stuff[MAX].filp, 0);
 320         check();
 321
 322         log("\nIncrease min to RP0 (invalid)...\n");
 323         writeval_inval(stuff[MIN].filp, origfreqs[RP0]);
 324         check();
 325
 326         log("\nIncrease max to midpoint...\n");
 327         writeval(stuff[MAX].filp, fmid);
 328         check();
 329
 330         log("\nIncrease max to RP0...\n");
 331         writeval(stuff[MAX].filp, origfreqs[RP0]);
 332         check();
 333
 334         log("\nIncrease max above RP0 (invalid)...\n");
 335         writeval_inval(stuff[MAX].filp, origfreqs[RP0] + 1000);
 336         check();
 337
 338         writeval(stuff[MIN].filp, origfreqs[MIN]);
 339         writeval(stuff[MAX].filp, origfreqs[MAX]);
 340 }
 341
 342 static void basic_check(void)
 343 {
 344         int freqs[NUMFREQ];
 345
 346         read_freqs(freqs);
 347         dump(freqs);
 348         checkit(freqs);
 349 }
 350
 351 #define IDLE_WAIT_TIMESTEP_MSEC 100
 352 #define IDLE_WAIT_TIMEOUT_MSEC 3000
 353 static void idle_check(void)
 354 {
 355         int freqs[NUMFREQ];
 356         int wait = 0;
 357
 358         /* Monitor frequencies until cur settles down to min, which should
 359          * happen within the allotted time */
 360         do {
 361                 read_freqs(freqs);
 362                 dump(freqs);
 363                 checkit(freqs);
 364                 if (freqs[CUR] == freqs[MIN])
 365                         break;
 366                 usleep(1000 * IDLE_WAIT_TIMESTEP_MSEC);
 367                 wait += IDLE_WAIT_TIMESTEP_MSEC;
 368         } while (wait < IDLE_WAIT_TIMEOUT_MSEC);
 369
 370         igt_assert(freqs[CUR] == freqs[MIN]);
 371         log("Required %d msec to reach cur=min\n", wait);
 372 }
 373
 374 #define LOADED_WAIT_TIMESTEP_MSEC 100
 375 #define LOADED_WAIT_TIMEOUT_MSEC 3000
 376 static void loaded_check(void)
 377 {
 378         int freqs[NUMFREQ];
 379         int wait = 0;
 380
 381         /* Monitor frequencies until cur increases to max, which should
 382          * happen within the allotted time */
 383         do {
 384                 read_freqs(freqs);
 385                 dump(freqs);
 386                 checkit(freqs);
 387                 if (freqs[CUR] == freqs[MAX])
 388                         break;
 389                 usleep(1000 * LOADED_WAIT_TIMESTEP_MSEC);
 390                 wait += LOADED_WAIT_TIMESTEP_MSEC;
 391         } while (wait < LOADED_WAIT_TIMEOUT_MSEC);
 392
 393         igt_assert(freqs[CUR] == freqs[MAX]);
 394         log("Required %d msec to reach cur=max\n", wait);
 395 }
 396
 397 static void pm_rps_exit_handler(int sig)
 398 {
 399         if (origfreqs[MIN] > readval(stuff[MAX].filp)) {
 400                 writeval(stuff[MAX].filp, origfreqs[MAX]);
 401                 writeval(stuff[MIN].filp, origfreqs[MIN]);
 402         } else {
 403                 writeval(stuff[MIN].filp, origfreqs[MIN]);
 404                 writeval(stuff[MAX].filp, origfreqs[MAX]);
 405         }
 406
 407         load_helper_deinit();
 408         close(drm_fd);
 409 }
 410
 411 static int opt_handler(int opt, int opt_index)
 412 {
 413         switch (opt) {
 414         case 'v':
 415                 verbose = true;
 416                 break;
 417         default:
 418                 assert(0);
 419         }
 420
 421         return 0;
 422 }
 423
 424 /* Mod of igt_subtest_init that adds our extra options */
 425 static void subtest_init(int argc, char **argv)
 426 {
 427         struct option long_opts[] = {
 428                 {"verbose", 0, 0, 'v'}
 429         };
 430         const char *help_str = "  -v, --verbose";
 431         int ret;
 432
 433         ret = igt_subtest_init_parse_opts(argc, argv, "v", long_opts,
 434                                           help_str, opt_handler);
 435
 436         if (ret < 0)
 437                 /* exit with no error for -h/--help */
 438                 exit(ret == -1 ? 0 : ret);
 439 }
 440
 441 int main(int argc, char **argv)
 442 {
 443         subtest_init(argc, argv);
 444
 445         igt_skip_on_simulation();
 446
 447         igt_fixture {
 448                 const int device = drm_get_card();
 449                 struct junk *junk = stuff;
 450                 int ret;
 451
 452                 /* Use drm_open_any to verify device existence */
 453                 drm_fd = drm_open_any();
 454
 455                 do {
 456                         int val = -1;
 457                         char *path;
 458                         ret = asprintf(&path, sysfs_base_path, device, junk->name);
 459                         igt_assert(ret != -1);
 460                         junk->filp = fopen(path, junk->mode);
 461                         igt_require(junk->filp);
 462                         setbuf(junk->filp, NULL);
 463
 464                         val = readval(junk->filp);
 465                         igt_assert(val >= 0);
 466                         junk++;
 467                 } while(junk->name != NULL);
 468
 469                 read_freqs(origfreqs);
 470
 471                 igt_install_exit_handler(pm_rps_exit_handler);
 472
 473                 load_helper_init();
 474         }
 475
 476         igt_subtest("basic-api")
 477                 min_max_config(basic_check);
 478
 479         igt_subtest("min-max-config-idle")
 480                 min_max_config(idle_check);
 481
 482         igt_subtest("min-max-config-loaded") {
 483                 load_helper_run();
 484                 min_max_config(loaded_check);
 485                 load_helper_stop();
 486         }
 487
 488         igt_exit();
 489 }