1 /************************************************************************** 2 * 3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, TX., USA 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, 18 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 19 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 20 * USE OR OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * The above copyright notice and this permission notice (including the 23 * next paragraph) shall be included in all copies or substantial portions 24 * of the Software. 25 * 26 * 27 **************************************************************************/ 28 /* 29 * Authors: Thomas Hellstrm <thomas-at-tungstengraphics-dot-com> 30 */ 31 32 #ifdef HAVE_CONFIG_H 33 #include "config.h" 34 #endif 35 36 #include <X11/Xlib.h> 37 #include <X11/Xutil.h> 38 #include <stdint.h> 39 #include <drm/drm.h> 40 #include "xf86dri.h" 41 #include "xf86drm.h" 42 #include "stdio.h" 43 #include "sys/types.h" 44 #include <unistd.h> 45 #include <string.h> 46 #include <errno.h> 47 #include <stdlib.h> 48 #include "sys/mman.h" 49 50 typedef struct 51 { 52 enum 53 { 54 haveNothing, 55 haveDisplay, 56 haveConnection, 57 haveDriverName, 58 haveDeviceInfo, 59 haveDRM, 60 haveContext 61 } 62 state; 63 64 Display *display; 65 int screen; 66 drm_handle_t sAreaOffset; 67 char *curBusID; 68 char *driverName; 69 int drmFD; 70 XVisualInfo visualInfo; 71 XID id; 72 drm_context_t hwContext; 73 void *driPriv; 74 int driPrivSize; 75 int fbSize; 76 int fbOrigin; 77 int fbStride; 78 drm_handle_t fbHandle; 79 int ddxDriverMajor; 80 int ddxDriverMinor; 81 int ddxDriverPatch; 82 } TinyDRIContext; 83 84 #ifndef __x86_64__ 85 static unsigned 86 fastrdtsc(void) 87 { 88 unsigned eax; 89 __asm__ volatile ("\t" 90 "pushl %%ebx\n\t" 91 "cpuid\n\t" ".byte 0x0f, 0x31\n\t" "popl %%ebx\n":"=a" (eax) 92 :"0"(0) 93 :"ecx", "edx", "cc"); 94 95 return eax; 96 } 97 #else 98 static unsigned 99 fastrdtsc(void) 100 { 101 unsigned eax; 102 __asm__ volatile ("\t" "cpuid\n\t" ".byte 0x0f, 0x31\n\t":"=a" (eax) 103 :"0"(0) 104 :"ecx", "edx", "ebx", "cc"); 105 106 return eax; 107 } 108 #endif 109 110 void 111 bmError(int val, const char *file, const char *function, int line) 112 { 113 fprintf(stderr, "Fatal video memory manager error \"%s\".\n" 114 "Check kernel logs or set the LIBGL_DEBUG\n" 115 "environment variable to \"verbose\" for more info.\n" 116 "Detected in file %s, line %d, function %s.\n", 117 strerror(-val), file, line, function); 118 abort(); 119 } 120 121 #define BM_CKFATAL(val) \ 122 do{ \ 123 int tstVal = (val); \ 124 if (tstVal) \ 125 bmError(tstVal, __FILE__, __FUNCTION__, __LINE__); \ 126 } while(0); 127 128 static unsigned 129 time_diff(unsigned t, unsigned t2) 130 { 131 return ((t < t2) ? t2 - t : 0xFFFFFFFFU - (t - t2 - 1)); 132 } 133 134 static int 135 releaseContext(TinyDRIContext * ctx) 136 { 137 switch (ctx->state) { 138 case haveContext: 139 uniDRIDestroyContext(ctx->display, ctx->screen, ctx->id); 140 case haveDRM: 141 drmClose(ctx->drmFD); 142 case haveDeviceInfo: 143 XFree(ctx->driPriv); 144 case haveDriverName: 145 XFree(ctx->driverName); 146 case haveConnection: 147 XFree(ctx->curBusID); 148 uniDRICloseConnection(ctx->display, ctx->screen); 149 case haveDisplay: 150 XCloseDisplay(ctx->display); 151 default: 152 break; 153 } 154 return -1; 155 } 156 157 static void 158 readBuf(void *buf, unsigned long size) 159 { 160 volatile unsigned *buf32 = (unsigned *)buf; 161 unsigned *end = (unsigned *)buf32 + size / sizeof(*buf32); 162 163 while (buf32 < end) { 164 (void)*buf32++; 165 } 166 } 167 168 static int 169 benchmarkBuffer(TinyDRIContext * ctx, unsigned long size, 170 unsigned long *ticks) 171 { 172 unsigned long curTime, oldTime; 173 int ret; 174 drmBO buf; 175 void *virtual; 176 177 /* 178 * Test system memory objects. 179 */ 180 oldTime = fastrdtsc(); 181 BM_CKFATAL(drmBOCreate(ctx->drmFD, size, 0, NULL, 182 DRM_BO_FLAG_READ | 183 DRM_BO_FLAG_WRITE | 184 DRM_BO_FLAG_MEM_LOCAL, 0, &buf)); 185 curTime = fastrdtsc(); 186 *ticks++ = time_diff(oldTime, curTime); 187 188 oldTime = fastrdtsc(); 189 BM_CKFATAL(drmBOMap(ctx->drmFD, &buf, 190 DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE, 0, &virtual)); 191 curTime = fastrdtsc(); 192 *ticks++ = time_diff(oldTime, curTime); 193 194 oldTime = fastrdtsc(); 195 memset(virtual, 0xF0, buf.size); 196 curTime = fastrdtsc(); 197 *ticks++ = time_diff(oldTime, curTime); 198 199 oldTime = fastrdtsc(); 200 memset(virtual, 0x0F, buf.size); 201 curTime = fastrdtsc(); 202 *ticks++ = time_diff(oldTime, curTime); 203 204 oldTime = fastrdtsc(); 205 readBuf(virtual, buf.size); 206 curTime = fastrdtsc(); 207 *ticks++ = time_diff(oldTime, curTime); 208 209 oldTime = fastrdtsc(); 210 BM_CKFATAL(drmBOUnmap(ctx->drmFD, &buf)); 211 curTime = fastrdtsc(); 212 *ticks++ = time_diff(oldTime, curTime); 213 214 /* 215 * Test TT bound buffer objects. 216 */ 217 218 oldTime = fastrdtsc(); 219 BM_CKFATAL(drmBOSetStatus(ctx->drmFD, &buf, 220 DRM_BO_FLAG_MEM_TT, 221 DRM_BO_MASK_MEM, 222 0,0,0)); 223 curTime = fastrdtsc(); 224 *ticks++ = time_diff(oldTime, curTime); 225 226 oldTime = fastrdtsc(); 227 BM_CKFATAL(drmBOMap(ctx->drmFD, &buf, 228 DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE, 0, &virtual)); 229 curTime = fastrdtsc(); 230 *ticks++ = time_diff(oldTime, curTime); 231 232 oldTime = fastrdtsc(); 233 memset(virtual, 0xF0, buf.size); 234 curTime = fastrdtsc(); 235 *ticks++ = time_diff(oldTime, curTime); 236 237 oldTime = fastrdtsc(); 238 memset(virtual, 0x0F, buf.size); 239 curTime = fastrdtsc(); 240 *ticks++ = time_diff(oldTime, curTime); 241 242 oldTime = fastrdtsc(); 243 readBuf(virtual, buf.size); 244 curTime = fastrdtsc(); 245 *ticks++ = time_diff(oldTime, curTime); 246 247 BM_CKFATAL(drmBOUnmap(ctx->drmFD, &buf)); 248 249 oldTime = fastrdtsc(); 250 BM_CKFATAL(drmBOSetStatus(ctx->drmFD, &buf, 251 DRM_BO_FLAG_MEM_LOCAL, DRM_BO_MASK_MEM, 0, 0,0)); 252 curTime = fastrdtsc(); 253 *ticks++ = time_diff(oldTime, curTime); 254 255 /* 256 * Test cached buffers objects. 257 */ 258 259 oldTime = fastrdtsc(); 260 ret = drmBOSetStatus(ctx->drmFD, &buf, 261 DRM_BO_FLAG_MEM_TT | 262 DRM_BO_FLAG_CACHED | 263 DRM_BO_FLAG_FORCE_CACHING, 264 DRM_BO_MASK_MEMTYPE | 265 DRM_BO_FLAG_FORCE_CACHING, 266 0, 0, 0); 267 curTime = fastrdtsc(); 268 269 if (ret) { 270 printf("Couldn't bind cached. Probably no support\n"); 271 BM_CKFATAL(drmBOUnreference(ctx->drmFD, &buf)); 272 return 1; 273 } 274 *ticks++ = time_diff(oldTime, curTime); 275 276 oldTime = fastrdtsc(); 277 BM_CKFATAL(drmBOMap(ctx->drmFD, &buf, 278 DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE, 0, &virtual)); 279 280 curTime = fastrdtsc(); 281 *ticks++ = time_diff(oldTime, curTime); 282 283 oldTime = fastrdtsc(); 284 memset(virtual, 0xF0, buf.size); 285 curTime = fastrdtsc(); 286 *ticks++ = time_diff(oldTime, curTime); 287 288 oldTime = fastrdtsc(); 289 memset(virtual, 0x0F, buf.size); 290 curTime = fastrdtsc(); 291 *ticks++ = time_diff(oldTime, curTime); 292 293 oldTime = fastrdtsc(); 294 readBuf(virtual, buf.size); 295 curTime = fastrdtsc(); 296 *ticks++ = time_diff(oldTime, curTime); 297 298 BM_CKFATAL(drmBOUnmap(ctx->drmFD, &buf)); 299 BM_CKFATAL(drmBOUnreference(ctx->drmFD, &buf)); 300 301 return 0; 302 } 303 304 static void 305 testAGP(TinyDRIContext * ctx) 306 { 307 unsigned long ticks[128], *pTicks; 308 unsigned long size = 8 * 1024; 309 int ret; 310 311 ret = benchmarkBuffer(ctx, size, ticks); 312 if (ret < 0) { 313 fprintf(stderr, "Buffer error %s\n", strerror(-ret)); 314 return; 315 } 316 pTicks = ticks; 317 318 printf("Buffer size %d bytes\n", size); 319 printf("System memory timings ********************************\n"); 320 printf("Creation took %12lu ticks\n", *pTicks++); 321 printf("Mapping took %12lu ticks\n", *pTicks++); 322 printf("Writing took %12lu ticks\n", *pTicks++); 323 printf("Writing Again took %12lu ticks\n", *pTicks++); 324 printf("Reading took %12lu ticks\n", *pTicks++); 325 printf("Unmapping took %12lu ticks\n", *pTicks++); 326 327 printf("\nTT Memory timings ************************************\n"); 328 printf("Moving to TT took %12lu ticks\n", *pTicks++); 329 printf("Mapping in TT took %12lu ticks\n", *pTicks++); 330 printf("Writing to TT took %12lu ticks\n", *pTicks++); 331 printf("Writing again to TT took %12lu ticks\n", *pTicks++); 332 printf("Reading from TT took %12lu ticks\n", *pTicks++); 333 printf("Moving to system took %12lu ticks\n", *pTicks++); 334 335 if (ret == 1) 336 return; 337 338 printf("\nCached TT Memory timings *****************************\n"); 339 printf("Moving to CTT took %12lu ticks\n", *pTicks++); 340 printf("Mapping in CTT took %12lu ticks\n", *pTicks++); 341 printf("Writing to CTT took %12lu ticks\n", *pTicks++); 342 printf("Re-writing to CTT took %12lu ticks\n", *pTicks++); 343 printf("Reading from CTT took %12lu ticks\n", *pTicks++); 344 printf("\n\n"); 345 } 346 347 int 348 main() 349 { 350 int ret, screen, isCapable; 351 char *displayName = ":0"; 352 TinyDRIContext ctx; 353 unsigned magic; 354 355 ctx.screen = 0; 356 ctx.state = haveNothing; 357 ctx.display = XOpenDisplay(displayName); 358 if (!ctx.display) { 359 fprintf(stderr, "Could not open display\n"); 360 return releaseContext(&ctx); 361 } 362 ctx.state = haveDisplay; 363 364 ret = 365 uniDRIQueryDirectRenderingCapable(ctx.display, ctx.screen, 366 &isCapable); 367 if (!ret || !isCapable) { 368 fprintf(stderr, "No DRI on this display:sceen\n"); 369 return releaseContext(&ctx); 370 } 371 372 if (!uniDRIOpenConnection(ctx.display, ctx.screen, &ctx.sAreaOffset, 373 &ctx.curBusID)) { 374 fprintf(stderr, "Could not open DRI connection.\n"); 375 return releaseContext(&ctx); 376 } 377 ctx.state = haveConnection; 378 379 if (!uniDRIGetClientDriverName(ctx.display, ctx.screen, 380 &ctx.ddxDriverMajor, &ctx.ddxDriverMinor, 381 &ctx.ddxDriverPatch, &ctx.driverName)) { 382 fprintf(stderr, "Could not get DRI driver name.\n"); 383 return releaseContext(&ctx); 384 } 385 ctx.state = haveDriverName; 386 387 if (!uniDRIGetDeviceInfo(ctx.display, ctx.screen, 388 &ctx.fbHandle, &ctx.fbOrigin, &ctx.fbSize, 389 &ctx.fbStride, &ctx.driPrivSize, &ctx.driPriv)) { 390 fprintf(stderr, "Could not get DRI device info.\n"); 391 return releaseContext(&ctx); 392 } 393 ctx.state = haveDriverName; 394 395 if ((ctx.drmFD = drmOpen(NULL, ctx.curBusID)) < 0) { 396 perror("DRM Device could not be opened"); 397 return releaseContext(&ctx); 398 } 399 ctx.state = haveDRM; 400 401 drmGetMagic(ctx.drmFD, &magic); 402 if (!uniDRIAuthConnection(ctx.display, ctx.screen, magic)) { 403 fprintf(stderr, "Could not get X server to authenticate us.\n"); 404 return releaseContext(&ctx); 405 } 406 407 ret = XMatchVisualInfo(ctx.display, ctx.screen, 24, TrueColor, 408 &ctx.visualInfo); 409 if (!ret) { 410 ret = XMatchVisualInfo(ctx.display, ctx.screen, 16, TrueColor, 411 &ctx.visualInfo); 412 if (!ret) { 413 fprintf(stderr, "Could not find a matching visual.\n"); 414 return releaseContext(&ctx); 415 } 416 } 417 418 if (!uniDRICreateContext(ctx.display, ctx.screen, ctx.visualInfo.visual, 419 &ctx.id, &ctx.hwContext)) { 420 fprintf(stderr, "Could not create DRI context.\n"); 421 return releaseContext(&ctx); 422 } 423 ctx.state = haveContext; 424 425 testAGP(&ctx); 426 427 releaseContext(&ctx); 428 printf("Terminating normally\n"); 429 return 0; 430 } 431
