diff options
author | Kristian Høgsberg Kristensen | 2015-07-31 12:47:50 -0500 |
---|---|---|
committer | Kristian Høgsberg Kristensen | 2015-08-03 11:19:47 -0500 |
commit | cd2f91e18db087edf93fed828e568ee53b887860 (patch) | |
tree | a50e3c8d824f097aca87a3fc2bee2b2cae254e74 | |
parent | fc083322b0c8a58b51976adf23a582bce8bb75f1 (diff) | |
download | external-libdrm-cd2f91e18db087edf93fed828e568ee53b887860.tar.gz external-libdrm-cd2f91e18db087edf93fed828e568ee53b887860.tar.xz external-libdrm-cd2f91e18db087edf93fed828e568ee53b887860.zip |
intel: Drop aub dumping functionality
We now have a separate tool for this in intel-gpu-tools and we don't
need to clutter up libdrm with this feature. We leave the entry points
in there to avoid breaking API/ABI.
Install intel-gpu-tools, then run (for example)
$ intel_aubdump --output=trace.aub glxgears -geometry 500x500
See the intel_aubdump man page for more details.
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Signed-off-by: Kristian Høgsberg Kristensen <kristian.h.kristensen@intel.com>
-rw-r--r-- | intel/intel_bufmgr_gem.c | 375 |
1 files changed, 5 insertions, 370 deletions
diff --git a/intel/intel_bufmgr_gem.c b/intel/intel_bufmgr_gem.c index b1c3b3a1..41de396b 100644 --- a/intel/intel_bufmgr_gem.c +++ b/intel/intel_bufmgr_gem.c | |||
@@ -61,7 +61,6 @@ | |||
61 | #include "intel_bufmgr.h" | 61 | #include "intel_bufmgr.h" |
62 | #include "intel_bufmgr_priv.h" | 62 | #include "intel_bufmgr_priv.h" |
63 | #include "intel_chipset.h" | 63 | #include "intel_chipset.h" |
64 | #include "intel_aub.h" | ||
65 | #include "string.h" | 64 | #include "string.h" |
66 | 65 | ||
67 | #include "i915_drm.h" | 66 | #include "i915_drm.h" |
@@ -138,9 +137,6 @@ typedef struct _drm_intel_bufmgr_gem { | |||
138 | uint32_t handle; | 137 | uint32_t handle; |
139 | } userptr_active; | 138 | } userptr_active; |
140 | 139 | ||
141 | char *aub_filename; | ||
142 | FILE *aub_file; | ||
143 | uint32_t aub_offset; | ||
144 | } drm_intel_bufmgr_gem; | 140 | } drm_intel_bufmgr_gem; |
145 | 141 | ||
146 | #define DRM_INTEL_RELOC_FENCE (1<<0) | 142 | #define DRM_INTEL_RELOC_FENCE (1<<0) |
@@ -256,11 +252,6 @@ struct _drm_intel_bo_gem { | |||
256 | 252 | ||
257 | /** Flags that we may need to do the SW_FINSIH ioctl on unmap. */ | 253 | /** Flags that we may need to do the SW_FINSIH ioctl on unmap. */ |
258 | bool mapped_cpu_write; | 254 | bool mapped_cpu_write; |
259 | |||
260 | uint32_t aub_offset; | ||
261 | |||
262 | drm_intel_aub_annotation *aub_annotations; | ||
263 | unsigned aub_annotation_count; | ||
264 | }; | 255 | }; |
265 | 256 | ||
266 | static unsigned int | 257 | static unsigned int |
@@ -789,8 +780,6 @@ retry: | |||
789 | bo_gem->used_as_reloc_target = false; | 780 | bo_gem->used_as_reloc_target = false; |
790 | bo_gem->has_error = false; | 781 | bo_gem->has_error = false; |
791 | bo_gem->reusable = true; | 782 | bo_gem->reusable = true; |
792 | bo_gem->aub_annotations = NULL; | ||
793 | bo_gem->aub_annotation_count = 0; | ||
794 | 783 | ||
795 | drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, alignment); | 784 | drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, alignment); |
796 | 785 | ||
@@ -1143,7 +1132,6 @@ drm_intel_gem_bo_free(drm_intel_bo *bo) | |||
1143 | DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n", | 1132 | DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n", |
1144 | bo_gem->gem_handle, bo_gem->name, strerror(errno)); | 1133 | bo_gem->gem_handle, bo_gem->name, strerror(errno)); |
1145 | } | 1134 | } |
1146 | free(bo_gem->aub_annotations); | ||
1147 | free(bo); | 1135 | free(bo); |
1148 | } | 1136 | } |
1149 | 1137 | ||
@@ -1822,7 +1810,6 @@ drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr) | |||
1822 | free(bufmgr_gem->exec2_objects); | 1810 | free(bufmgr_gem->exec2_objects); |
1823 | free(bufmgr_gem->exec_objects); | 1811 | free(bufmgr_gem->exec_objects); |
1824 | free(bufmgr_gem->exec_bos); | 1812 | free(bufmgr_gem->exec_bos); |
1825 | free(bufmgr_gem->aub_filename); | ||
1826 | 1813 | ||
1827 | pthread_mutex_destroy(&bufmgr_gem->lock); | 1814 | pthread_mutex_destroy(&bufmgr_gem->lock); |
1828 | 1815 | ||
@@ -2116,297 +2103,12 @@ drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem) | |||
2116 | } | 2103 | } |
2117 | } | 2104 | } |
2118 | 2105 | ||
2119 | static void | ||
2120 | aub_out(drm_intel_bufmgr_gem *bufmgr_gem, uint32_t data) | ||
2121 | { | ||
2122 | fwrite(&data, 1, 4, bufmgr_gem->aub_file); | ||
2123 | } | ||
2124 | |||
2125 | static void | ||
2126 | aub_out_data(drm_intel_bufmgr_gem *bufmgr_gem, void *data, size_t size) | ||
2127 | { | ||
2128 | fwrite(data, 1, size, bufmgr_gem->aub_file); | ||
2129 | } | ||
2130 | |||
2131 | static void | ||
2132 | aub_write_bo_data(drm_intel_bo *bo, uint32_t offset, uint32_t size) | ||
2133 | { | ||
2134 | drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr; | ||
2135 | drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo; | ||
2136 | uint32_t *data; | ||
2137 | unsigned int i; | ||
2138 | |||
2139 | data = malloc(bo->size); | ||
2140 | drm_intel_bo_get_subdata(bo, offset, size, data); | ||
2141 | |||
2142 | /* Easy mode: write out bo with no relocations */ | ||
2143 | if (!bo_gem->reloc_count) { | ||
2144 | aub_out_data(bufmgr_gem, data, size); | ||
2145 | free(data); | ||
2146 | return; | ||
2147 | } | ||
2148 | |||
2149 | /* Otherwise, handle the relocations while writing. */ | ||
2150 | for (i = 0; i < size / 4; i++) { | ||
2151 | int r; | ||
2152 | for (r = 0; r < bo_gem->reloc_count; r++) { | ||
2153 | struct drm_i915_gem_relocation_entry *reloc; | ||
2154 | drm_intel_reloc_target *info; | ||
2155 | |||
2156 | reloc = &bo_gem->relocs[r]; | ||
2157 | info = &bo_gem->reloc_target_info[r]; | ||
2158 | |||
2159 | if (reloc->offset == offset + i * 4) { | ||
2160 | drm_intel_bo_gem *target_gem; | ||
2161 | uint32_t val; | ||
2162 | |||
2163 | target_gem = (drm_intel_bo_gem *)info->bo; | ||
2164 | |||
2165 | val = reloc->delta; | ||
2166 | val += target_gem->aub_offset; | ||
2167 | |||
2168 | aub_out(bufmgr_gem, val); | ||
2169 | data[i] = val; | ||
2170 | break; | ||
2171 | } | ||
2172 | } | ||
2173 | if (r == bo_gem->reloc_count) { | ||
2174 | /* no relocation, just the data */ | ||
2175 | aub_out(bufmgr_gem, data[i]); | ||
2176 | } | ||
2177 | } | ||
2178 | |||
2179 | free(data); | ||
2180 | } | ||
2181 | |||
2182 | static void | ||
2183 | aub_bo_get_address(drm_intel_bo *bo) | ||
2184 | { | ||
2185 | drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr; | ||
2186 | drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo; | ||
2187 | |||
2188 | /* Give the object a graphics address in the AUB file. We | ||
2189 | * don't just use the GEM object address because we do AUB | ||
2190 | * dumping before execution -- we want to successfully log | ||
2191 | * when the hardware might hang, and we might even want to aub | ||
2192 | * capture for a driver trying to execute on a different | ||
2193 | * generation of hardware by disabling the actual kernel exec | ||
2194 | * call. | ||
2195 | */ | ||
2196 | bo_gem->aub_offset = bufmgr_gem->aub_offset; | ||
2197 | bufmgr_gem->aub_offset += bo->size; | ||
2198 | /* XXX: Handle aperture overflow. */ | ||
2199 | assert(bufmgr_gem->aub_offset < 256 * 1024 * 1024); | ||
2200 | } | ||
2201 | |||
2202 | static void | ||
2203 | aub_write_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype, | ||
2204 | uint32_t offset, uint32_t size) | ||
2205 | { | ||
2206 | drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr; | ||
2207 | drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo; | ||
2208 | |||
2209 | aub_out(bufmgr_gem, | ||
2210 | CMD_AUB_TRACE_HEADER_BLOCK | | ||
2211 | ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2)); | ||
2212 | aub_out(bufmgr_gem, | ||
2213 | AUB_TRACE_MEMTYPE_GTT | type | AUB_TRACE_OP_DATA_WRITE); | ||
2214 | aub_out(bufmgr_gem, subtype); | ||
2215 | aub_out(bufmgr_gem, bo_gem->aub_offset + offset); | ||
2216 | aub_out(bufmgr_gem, size); | ||
2217 | if (bufmgr_gem->gen >= 8) | ||
2218 | aub_out(bufmgr_gem, 0); | ||
2219 | aub_write_bo_data(bo, offset, size); | ||
2220 | } | ||
2221 | |||
2222 | /** | ||
2223 | * Break up large objects into multiple writes. Otherwise a 128kb VBO | ||
2224 | * would overflow the 16 bits of size field in the packet header and | ||
2225 | * everything goes badly after that. | ||
2226 | */ | ||
2227 | static void | ||
2228 | aub_write_large_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype, | ||
2229 | uint32_t offset, uint32_t size) | ||
2230 | { | ||
2231 | uint32_t block_size; | ||
2232 | uint32_t sub_offset; | ||
2233 | |||
2234 | for (sub_offset = 0; sub_offset < size; sub_offset += block_size) { | ||
2235 | block_size = size - sub_offset; | ||
2236 | |||
2237 | if (block_size > 8 * 4096) | ||
2238 | block_size = 8 * 4096; | ||
2239 | |||
2240 | aub_write_trace_block(bo, type, subtype, offset + sub_offset, | ||
2241 | block_size); | ||
2242 | } | ||
2243 | } | ||
2244 | |||
2245 | static void | ||
2246 | aub_write_bo(drm_intel_bo *bo) | ||
2247 | { | ||
2248 | drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo; | ||
2249 | uint32_t offset = 0; | ||
2250 | unsigned i; | ||
2251 | |||
2252 | aub_bo_get_address(bo); | ||
2253 | |||
2254 | /* Write out each annotated section separately. */ | ||
2255 | for (i = 0; i < bo_gem->aub_annotation_count; ++i) { | ||
2256 | drm_intel_aub_annotation *annotation = | ||
2257 | &bo_gem->aub_annotations[i]; | ||
2258 | uint32_t ending_offset = annotation->ending_offset; | ||
2259 | if (ending_offset > bo->size) | ||
2260 | ending_offset = bo->size; | ||
2261 | if (ending_offset > offset) { | ||
2262 | aub_write_large_trace_block(bo, annotation->type, | ||
2263 | annotation->subtype, | ||
2264 | offset, | ||
2265 | ending_offset - offset); | ||
2266 | offset = ending_offset; | ||
2267 | } | ||
2268 | } | ||
2269 | |||
2270 | /* Write out any remaining unannotated data */ | ||
2271 | if (offset < bo->size) { | ||
2272 | aub_write_large_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0, | ||
2273 | offset, bo->size - offset); | ||
2274 | } | ||
2275 | } | ||
2276 | |||
2277 | /* | ||
2278 | * Make a ringbuffer on fly and dump it | ||
2279 | */ | ||
2280 | static void | ||
2281 | aub_build_dump_ringbuffer(drm_intel_bufmgr_gem *bufmgr_gem, | ||
2282 | uint32_t batch_buffer, int ring_flag) | ||
2283 | { | ||
2284 | uint32_t ringbuffer[4096]; | ||
2285 | int ring = AUB_TRACE_TYPE_RING_PRB0; /* The default ring */ | ||
2286 | int ring_count = 0; | ||
2287 | |||
2288 | if (ring_flag == I915_EXEC_BSD) | ||
2289 | ring = AUB_TRACE_TYPE_RING_PRB1; | ||
2290 | else if (ring_flag == I915_EXEC_BLT) | ||
2291 | ring = AUB_TRACE_TYPE_RING_PRB2; | ||
2292 | |||
2293 | /* Make a ring buffer to execute our batchbuffer. */ | ||
2294 | memset(ringbuffer, 0, sizeof(ringbuffer)); | ||
2295 | if (bufmgr_gem->gen >= 8) { | ||
2296 | ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START | (3 - 2); | ||
2297 | ringbuffer[ring_count++] = batch_buffer; | ||
2298 | ringbuffer[ring_count++] = 0; | ||
2299 | } else { | ||
2300 | ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START; | ||
2301 | ringbuffer[ring_count++] = batch_buffer; | ||
2302 | } | ||
2303 | |||
2304 | /* Write out the ring. This appears to trigger execution of | ||
2305 | * the ring in the simulator. | ||
2306 | */ | ||
2307 | aub_out(bufmgr_gem, | ||
2308 | CMD_AUB_TRACE_HEADER_BLOCK | | ||
2309 | ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2)); | ||
2310 | aub_out(bufmgr_gem, | ||
2311 | AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE); | ||
2312 | aub_out(bufmgr_gem, 0); /* general/surface subtype */ | ||
2313 | aub_out(bufmgr_gem, bufmgr_gem->aub_offset); | ||
2314 | aub_out(bufmgr_gem, ring_count * 4); | ||
2315 | if (bufmgr_gem->gen >= 8) | ||
2316 | aub_out(bufmgr_gem, 0); | ||
2317 | |||
2318 | /* FIXME: Need some flush operations here? */ | ||
2319 | aub_out_data(bufmgr_gem, ringbuffer, ring_count * 4); | ||
2320 | |||
2321 | /* Update offset pointer */ | ||
2322 | bufmgr_gem->aub_offset += 4096; | ||
2323 | } | ||
2324 | |||
2325 | void | 2106 | void |
2326 | drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo, | 2107 | drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo, |
2327 | int x1, int y1, int width, int height, | 2108 | int x1, int y1, int width, int height, |
2328 | enum aub_dump_bmp_format format, | 2109 | enum aub_dump_bmp_format format, |
2329 | int pitch, int offset) | 2110 | int pitch, int offset) |
2330 | { | 2111 | { |
2331 | drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr; | ||
2332 | drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo; | ||
2333 | uint32_t cpp; | ||
2334 | |||
2335 | switch (format) { | ||
2336 | case AUB_DUMP_BMP_FORMAT_8BIT: | ||
2337 | cpp = 1; | ||
2338 | break; | ||
2339 | case AUB_DUMP_BMP_FORMAT_ARGB_4444: | ||
2340 | cpp = 2; | ||
2341 | break; | ||
2342 | case AUB_DUMP_BMP_FORMAT_ARGB_0888: | ||
2343 | case AUB_DUMP_BMP_FORMAT_ARGB_8888: | ||
2344 | cpp = 4; | ||
2345 | break; | ||
2346 | default: | ||
2347 | printf("Unknown AUB dump format %d\n", format); | ||
2348 | return; | ||
2349 | } | ||
2350 | |||
2351 | if (!bufmgr_gem->aub_file) | ||
2352 | return; | ||
2353 | |||
2354 | aub_out(bufmgr_gem, CMD_AUB_DUMP_BMP | 4); | ||
2355 | aub_out(bufmgr_gem, (y1 << 16) | x1); | ||
2356 | aub_out(bufmgr_gem, | ||
2357 | (format << 24) | | ||
2358 | (cpp << 19) | | ||
2359 | pitch / 4); | ||
2360 | aub_out(bufmgr_gem, (height << 16) | width); | ||
2361 | aub_out(bufmgr_gem, bo_gem->aub_offset + offset); | ||
2362 | aub_out(bufmgr_gem, | ||
2363 | ((bo_gem->tiling_mode != I915_TILING_NONE) ? (1 << 2) : 0) | | ||
2364 | ((bo_gem->tiling_mode == I915_TILING_Y) ? (1 << 3) : 0)); | ||
2365 | } | ||
2366 | |||
2367 | static void | ||
2368 | aub_exec(drm_intel_bo *bo, int ring_flag, int used) | ||
2369 | { | ||
2370 | drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr; | ||
2371 | drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo; | ||
2372 | int i; | ||
2373 | bool batch_buffer_needs_annotations; | ||
2374 | |||
2375 | if (!bufmgr_gem->aub_file) | ||
2376 | return; | ||
2377 | |||
2378 | /* If batch buffer is not annotated, annotate it the best we | ||
2379 | * can. | ||
2380 | */ | ||
2381 | batch_buffer_needs_annotations = bo_gem->aub_annotation_count == 0; | ||
2382 | if (batch_buffer_needs_annotations) { | ||
2383 | drm_intel_aub_annotation annotations[2] = { | ||
2384 | { AUB_TRACE_TYPE_BATCH, 0, used }, | ||
2385 | { AUB_TRACE_TYPE_NOTYPE, 0, bo->size } | ||
2386 | }; | ||
2387 | drm_intel_bufmgr_gem_set_aub_annotations(bo, annotations, 2); | ||
2388 | } | ||
2389 | |||
2390 | /* Write out all buffers to AUB memory */ | ||
2391 | for (i = 0; i < bufmgr_gem->exec_count; i++) { | ||
2392 | aub_write_bo(bufmgr_gem->exec_bos[i]); | ||
2393 | } | ||
2394 | |||
2395 | /* Remove any annotations we added */ | ||
2396 | if (batch_buffer_needs_annotations) | ||
2397 | drm_intel_bufmgr_gem_set_aub_annotations(bo, NULL, 0); | ||
2398 | |||
2399 | /* Dump ring buffer */ | ||
2400 | aub_build_dump_ringbuffer(bufmgr_gem, bo_gem->aub_offset, ring_flag); | ||
2401 | |||
2402 | fflush(bufmgr_gem->aub_file); | ||
2403 | |||
2404 | /* | ||
2405 | * One frame has been dumped. So reset the aub_offset for the next frame. | ||
2406 | * | ||
2407 | * FIXME: Can we do this? | ||
2408 | */ | ||
2409 | bufmgr_gem->aub_offset = 0x10000; | ||
2410 | } | 2112 | } |
2411 | 2113 | ||
2412 | static int | 2114 | static int |
@@ -2533,8 +2235,6 @@ do_exec2(drm_intel_bo *bo, int used, drm_intel_context *ctx, | |||
2533 | i915_execbuffer2_set_context_id(execbuf, ctx->ctx_id); | 2235 | i915_execbuffer2_set_context_id(execbuf, ctx->ctx_id); |
2534 | execbuf.rsvd2 = 0; | 2236 | execbuf.rsvd2 = 0; |
2535 | 2237 | ||
2536 | aub_exec(bo, flags, used); | ||
2537 | |||
2538 | if (bufmgr_gem->no_exec) | 2238 | if (bufmgr_gem->no_exec) |
2539 | goto skip_execution; | 2239 | goto skip_execution; |
2540 | 2240 | ||
@@ -3210,11 +2910,6 @@ void | |||
3210 | drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr, | 2910 | drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr, |
3211 | const char *filename) | 2911 | const char *filename) |
3212 | { | 2912 | { |
3213 | drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr; | ||
3214 | |||
3215 | free(bufmgr_gem->aub_filename); | ||
3216 | if (filename) | ||
3217 | bufmgr_gem->aub_filename = strdup(filename); | ||
3218 | } | 2913 | } |
3219 | 2914 | ||
3220 | /** | 2915 | /** |
@@ -3228,58 +2923,11 @@ drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr, | |||
3228 | void | 2923 | void |
3229 | drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable) | 2924 | drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable) |
3230 | { | 2925 | { |
3231 | drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr; | 2926 | fprintf(stderr, "libdrm aub dumping is deprecated.\n\n" |
3232 | int entry = 0x200003; | 2927 | "Use intel_aubdump from intel-gpu-tools instead. Install intel-gpu-tools,\n" |
3233 | int i; | 2928 | "then run (for example)\n\n" |
3234 | int gtt_size = 0x10000; | 2929 | "\t$ intel_aubdump --output=trace.aub glxgears -geometry 500x500\n\n" |
3235 | const char *filename; | 2930 | "See the intel_aubdump man page for more details.\n"); |
3236 | |||
3237 | if (!enable) { | ||
3238 | if (bufmgr_gem->aub_file) { | ||
3239 | fclose(bufmgr_gem->aub_file); | ||
3240 | bufmgr_gem->aub_file = NULL; | ||
3241 | } | ||
3242 | return; | ||
3243 | } | ||
3244 | |||
3245 | if (geteuid() != getuid()) | ||
3246 | return; | ||
3247 | |||
3248 | if (bufmgr_gem->aub_filename) | ||
3249 | filename = bufmgr_gem->aub_filename; | ||
3250 | else | ||
3251 | filename = "intel.aub"; | ||
3252 | bufmgr_gem->aub_file = fopen(filename, "w+"); | ||
3253 | if (!bufmgr_gem->aub_file) | ||
3254 | return; | ||
3255 | |||
3256 | /* Start allocating objects from just after the GTT. */ | ||
3257 | bufmgr_gem->aub_offset = gtt_size; | ||
3258 | |||
3259 | /* Start with a (required) version packet. */ | ||
3260 | aub_out(bufmgr_gem, CMD_AUB_HEADER | (13 - 2)); | ||
3261 | aub_out(bufmgr_gem, | ||
3262 | (4 << AUB_HEADER_MAJOR_SHIFT) | | ||
3263 | (0 << AUB_HEADER_MINOR_SHIFT)); | ||
3264 | for (i = 0; i < 8; i++) { | ||
3265 | aub_out(bufmgr_gem, 0); /* app name */ | ||
3266 | } | ||
3267 | aub_out(bufmgr_gem, 0); /* timestamp */ | ||
3268 | aub_out(bufmgr_gem, 0); /* timestamp */ | ||
3269 | aub_out(bufmgr_gem, 0); /* comment len */ | ||
3270 | |||
3271 | /* Set up the GTT. The max we can handle is 256M */ | ||
3272 | aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2)); | ||
3273 | /* Need to use GTT_ENTRY type for recent emulator */ | ||
3274 | aub_out(bufmgr_gem, AUB_TRACE_MEMTYPE_GTT_ENTRY | 0 | AUB_TRACE_OP_DATA_WRITE); | ||
3275 | aub_out(bufmgr_gem, 0); /* subtype */ | ||
3276 | aub_out(bufmgr_gem, 0); /* offset */ | ||
3277 | aub_out(bufmgr_gem, gtt_size); /* size */ | ||
3278 | if (bufmgr_gem->gen >= 8) | ||
3279 | aub_out(bufmgr_gem, 0); | ||
3280 | for (i = 0x000; i < gtt_size; i += 4, entry += 0x1000) { | ||
3281 | aub_out(bufmgr_gem, entry); | ||
3282 | } | ||
3283 | } | 2931 | } |
3284 | 2932 | ||
3285 | drm_intel_context * | 2933 | drm_intel_context * |
@@ -3442,19 +3090,6 @@ drm_intel_bufmgr_gem_set_aub_annotations(drm_intel_bo *bo, | |||
3442 | drm_intel_aub_annotation *annotations, | 3090 | drm_intel_aub_annotation *annotations, |
3443 | unsigned count) | 3091 | unsigned count) |
3444 | { | 3092 | { |
3445 | drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo; | ||
3446 | unsigned size = sizeof(*annotations) * count; | ||
3447 | drm_intel_aub_annotation *new_annotations = | ||
3448 | count > 0 ? realloc(bo_gem->aub_annotations, size) : NULL; | ||
3449 | if (new_annotations == NULL) { | ||
3450 | free(bo_gem->aub_annotations); | ||
3451 | bo_gem->aub_annotations = NULL; | ||
3452 | bo_gem->aub_annotation_count = 0; | ||
3453 | return; | ||
3454 | } | ||
3455 | memcpy(new_annotations, annotations, size); | ||
3456 | bo_gem->aub_annotations = new_annotations; | ||
3457 | bo_gem->aub_annotation_count = count; | ||
3458 | } | 3093 | } |
3459 | 3094 | ||
3460 | static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER; | 3095 | static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER; |