1 /*
2 * Copyright © 2007, 2011, 2013, 2014 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 * Eric Anholt <eric@anholt.net>
25 * Daniel Vetter <daniel.vetter@ffwll.ch>
26 * Tvrtko Ursulin <tvrtko.ursulin@intel.com>
27 *
28 */
29
30 #include "igt.h"
31 #include <stdlib.h>
32
33
34 struct igt_eviction_test_ops {
35 uint32_t (*create)(int fd, uint64_t size);
36 void (*flink)(uint32_t old_handle, uint32_t new_handle);
37 void (*close)(int fd, uint32_t bo);
38 int (*copy)(int fd, uint32_t dst, uint32_t src,
39 uint32_t *all_bo, int nr_bos);
40 void (*clear)(int fd, uint32_t bo, uint64_t size);
41 };
42
43 #define FORKING_EVICTIONS_INTERRUPTIBLE (1 << 0)
44 #define FORKING_EVICTIONS_SWAPPING (1 << 1)
45 #define FORKING_EVICTIONS_DUP_DRMFD (1 << 2)
46 #define FORKING_EVICTIONS_MEMORY_PRESSURE (1 << 3)
47 #define ALL_FORKING_EVICTIONS (FORKING_EVICTIONS_INTERRUPTIBLE | \
48 FORKING_EVICTIONS_SWAPPING | \
49 FORKING_EVICTIONS_DUP_DRMFD | \
50 FORKING_EVICTIONS_MEMORY_PRESSURE)
51
exchange_uint32_t(void * array,unsigned i,unsigned j)52 static void exchange_uint32_t(void *array, unsigned i, unsigned j)
53 {
54 uint32_t *i_arr = array;
55
56 igt_swap(i_arr[i], i_arr[j]);
57 }
58
minor_evictions(int fd,struct igt_eviction_test_ops * ops,uint64_t surface_size,uint64_t nr_surfaces)59 static int minor_evictions(int fd, struct igt_eviction_test_ops *ops,
60 uint64_t surface_size,
61 uint64_t nr_surfaces)
62 {
63 uint32_t *bo, *sel;
64 uint64_t n, m, total_surfaces;
65 int pass, fail;
66
67 /* Make sure nr_surfaces is not divisible by seven
68 * to avoid duplicates in the selection loop below.
69 */
70 nr_surfaces /= 7;
71 nr_surfaces *= 7;
72 nr_surfaces += 3;
73
74 total_surfaces = gem_aperture_size(fd) / surface_size + 1;
75 igt_require(nr_surfaces < total_surfaces);
76 intel_require_memory(total_surfaces, surface_size, CHECK_RAM);
77
78 bo = malloc((nr_surfaces + total_surfaces)*sizeof(*bo));
79 igt_assert(bo);
80
81 for (n = 0; n < total_surfaces; n++)
82 bo[n] = ops->create(fd, surface_size);
83
84 sel = bo + n;
85 for (fail = 0, m = 0; fail < 10; fail++) {
86 int ret;
87 for (pass = 0; pass < 100; pass++) {
88 for (n = 0; n < nr_surfaces; n++, m += 7)
89 sel[n] = bo[m%total_surfaces];
90 ret = ops->copy(fd, sel[0], sel[1], sel, nr_surfaces);
91 igt_assert_eq(ret, 0);
92 }
93 ret = ops->copy(fd, bo[0], bo[0], bo, total_surfaces);
94 igt_assert_eq(ret, -ENOSPC);
95 }
96
97 for (n = 0; n < total_surfaces; n++)
98 ops->close(fd, bo[n]);
99 free(bo);
100
101 return 0;
102 }
103
major_evictions(int fd,struct igt_eviction_test_ops * ops,uint64_t surface_size,uint64_t nr_surfaces)104 static int major_evictions(int fd, struct igt_eviction_test_ops *ops,
105 uint64_t surface_size, uint64_t nr_surfaces)
106 {
107 uint64_t n, m;
108 uint32_t *bo;
109 int ret, loop;
110
111 intel_require_memory(nr_surfaces, surface_size, CHECK_RAM);
112
113 bo = malloc(nr_surfaces*sizeof(*bo));
114 igt_assert(bo);
115
116 for (n = 0; n < nr_surfaces; n++)
117 bo[n] = ops->create(fd, surface_size);
118
119 for (loop = 0, m = 0; loop < 100; loop++, m += 17) {
120 n = m % nr_surfaces;
121 ret = ops->copy(fd, bo[n], bo[n], &bo[n], 1);
122 igt_assert_eq(ret, 0);
123 }
124
125 for (n = 0; n < nr_surfaces; n++)
126 ops->close(fd, bo[n]);
127 free(bo);
128
129 return 0;
130 }
131
mlocked_evictions(int fd,struct igt_eviction_test_ops * ops,uint64_t surface_size,uint64_t surface_count)132 static void mlocked_evictions(int fd, struct igt_eviction_test_ops *ops,
133 uint64_t surface_size,
134 uint64_t surface_count)
135 {
136 uint64_t sz, pin, total;
137 void *mem;
138
139 intel_require_memory(surface_count, surface_size, CHECK_RAM);
140
141 mem = intel_get_total_pinnable_mem(&total);
142 igt_assert(mem != MAP_FAILED);
143 pin = *(uint64_t *)mem;
144 igt_assert(!munlock(mem, pin));
145
146 sz = surface_size * surface_count;
147 igt_require(pin > sz);
148
149 igt_fork(child, 1) {
150 uint32_t *bo;
151 uint64_t n;
152 int ret;
153 size_t lock = pin - sz;
154
155 bo = malloc(surface_count * sizeof(*bo));
156 igt_assert(bo);
157 lock -= ALIGN(surface_count * sizeof(*bo), 4096);
158
159 igt_debug("Locking %'zu B (%'zu MiB)\n",
160 lock, lock >> 20);
161 igt_assert(!mlock(mem, lock));
162 igt_info("Locked %'zu B (%'zu MiB)\n",
163 lock, lock >> 20);
164
165 for (n = 0; n < surface_count; n++)
166 bo[n] = ops->create(fd, surface_size);
167
168 for (n = 0; n < surface_count - 2; n++) {
169 igt_permute_array(bo, surface_count, exchange_uint32_t);
170 ret = ops->copy(fd, bo[0], bo[1], bo, surface_count-n);
171 if (ret)
172 exit(ret);
173
174 /* Having used the surfaces (and so pulled out of
175 * our pages into memory), start a memory hog to
176 * force evictions.
177 */
178 lock += surface_size;
179 igt_assert(!mlock(mem, lock));
180 igt_debug("Total locked %'zu B (%'zu MiB)\n",
181 lock,
182 lock >> 20);
183 }
184
185 for (n = 0; n < surface_count; n++)
186 ops->close(fd, bo[n]);
187 }
188 igt_waitchildren();
189
190 munmap(mem, total);
191 }
192
swapping_evictions(int fd,struct igt_eviction_test_ops * ops,uint64_t surface_size,uint64_t working_surfaces,uint64_t trash_surfaces)193 static int swapping_evictions(int fd, struct igt_eviction_test_ops *ops,
194 uint64_t surface_size,
195 uint64_t working_surfaces,
196 uint64_t trash_surfaces)
197 {
198 uint32_t *bo;
199 uint64_t i, n;
200 int pass, ret;
201
202 intel_require_memory(working_surfaces, surface_size, CHECK_RAM);
203
204 if (trash_surfaces < working_surfaces)
205 trash_surfaces = working_surfaces;
206
207 intel_require_memory(trash_surfaces, surface_size, CHECK_RAM | CHECK_SWAP);
208
209 bo = malloc(trash_surfaces*sizeof(*bo));
210 igt_assert(bo);
211
212 for (n = 0; n < trash_surfaces; n++)
213 bo[n] = ops->create(fd, surface_size);
214
215 for (i = 0; i < trash_surfaces/32; i++) {
216 igt_permute_array(bo, trash_surfaces, exchange_uint32_t);
217
218 for (pass = 0; pass < 100; pass++) {
219 ret = ops->copy(fd, bo[0], bo[1], bo, working_surfaces);
220 igt_assert_eq(ret, 0);
221 }
222 }
223
224 for (n = 0; n < trash_surfaces; n++)
225 ops->close(fd, bo[n]);
226 free(bo);
227
228 return 0;
229 }
230
forking_evictions(int fd,struct igt_eviction_test_ops * ops,uint64_t surface_size,uint64_t working_surfaces,uint64_t trash_surfaces,unsigned flags)231 static int forking_evictions(int fd, struct igt_eviction_test_ops *ops,
232 uint64_t surface_size,
233 uint64_t working_surfaces,
234 uint64_t trash_surfaces,
235 unsigned flags)
236 {
237 const int num_threads = sysconf(_SC_NPROCESSORS_ONLN);
238 uint64_t bo_count, n, l;
239 uint32_t *bo;
240 int pass, ret;
241
242 intel_require_memory(working_surfaces, surface_size, CHECK_RAM);
243
244 if (flags & FORKING_EVICTIONS_SWAPPING) {
245 bo_count = trash_surfaces;
246 if (bo_count < working_surfaces)
247 bo_count = working_surfaces;
248
249 } else
250 bo_count = working_surfaces;
251
252 igt_assert_lte(working_surfaces, bo_count);
253 intel_require_memory(bo_count, surface_size, CHECK_RAM | CHECK_SWAP);
254
255 bo = malloc(bo_count*sizeof(*bo));
256 igt_assert(bo);
257
258 for (n = 0; n < bo_count; n++)
259 bo[n] = ops->create(fd, surface_size);
260
261 igt_fork(i, min(num_threads * 4, 12)) {
262 int realfd = fd;
263 int num_passes = flags & FORKING_EVICTIONS_SWAPPING ? 10 : 100;
264
265 /* Every fork should have a different permutation! */
266 srand(i * 63);
267
268 if (flags & FORKING_EVICTIONS_INTERRUPTIBLE)
269 igt_fork_signal_helper();
270
271 igt_permute_array(bo, bo_count, exchange_uint32_t);
272
273 if (flags & FORKING_EVICTIONS_DUP_DRMFD) {
274 realfd = drm_open_driver(DRIVER_INTEL);
275
276 /* We can overwrite the bo array since we're forked. */
277 for (l = 0; l < bo_count; l++) {
278 uint32_t handle = bo[l];
279 uint32_t flink = gem_flink(fd, bo[l]);
280
281 bo[l] = gem_open(realfd, flink);
282 if (ops->flink)
283 ops->flink(handle, bo[l]);
284 }
285 }
286
287 for (pass = 0; pass < num_passes; pass++) {
288 ret = ops->copy(realfd, bo[0], bo[1], bo, working_surfaces);
289 igt_assert_eq(ret, 0);
290
291 for (l = 0; l < working_surfaces &&
292 (flags & FORKING_EVICTIONS_MEMORY_PRESSURE);
293 l++) {
294 ops->clear(realfd, bo[l], surface_size);
295 }
296 }
297
298 if (flags & FORKING_EVICTIONS_INTERRUPTIBLE)
299 igt_stop_signal_helper();
300
301 /* drmfd closing will take care of additional bo refs */
302 if (flags & FORKING_EVICTIONS_DUP_DRMFD)
303 close(realfd);
304 }
305
306 igt_waitchildren();
307
308 for (n = 0; n < bo_count; n++)
309 ops->close(fd, bo[n]);
310 free(bo);
311
312 return 0;
313 }
314