i915_gem_evict.c revision 5eac3ab45955b32f3a9d89e633918c4d6f133dfa 
1/*
2 * Copyright © 2008-2010 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 *    Chris Wilson <chris@chris-wilson.co.uuk>
26 *
27 */
28
29#include "drmP.h"
30#include "drm.h"
31#include "i915_drv.h"
32#include "i915_drm.h"
33
34static bool
35mark_free(struct drm_i915_gem_object *obj_priv,
36	   struct list_head *unwind)
37{
38	list_add(&obj_priv->evict_list, unwind);
39	drm_gem_object_reference(&obj_priv->base);
40	return drm_mm_scan_add_block(obj_priv->gtt_space);
41}
42
43int
44i915_gem_evict_something(struct drm_device *dev, int min_size,
45			 unsigned alignment, bool mappable)
46{
47	drm_i915_private_t *dev_priv = dev->dev_private;
48	struct list_head eviction_list, unwind_list;
49	struct drm_i915_gem_object *obj_priv;
50	int ret = 0;
51
52	i915_gem_retire_requests(dev);
53
54	/* Re-check for free space after retiring requests */
55	if (mappable) {
56		if (drm_mm_search_free_in_range(&dev_priv->mm.gtt_space,
57						min_size, alignment, 0,
58						dev_priv->mm.gtt_mappable_end,
59						0))
60			return 0;
61	} else {
62		if (drm_mm_search_free(&dev_priv->mm.gtt_space,
63				       min_size, alignment, 0))
64			return 0;
65	}
66
67	/*
68	 * The goal is to evict objects and amalgamate space in LRU order.
69	 * The oldest idle objects reside on the inactive list, which is in
70	 * retirement order. The next objects to retire are those on the (per
71	 * ring) active list that do not have an outstanding flush. Once the
72	 * hardware reports completion (the seqno is updated after the
73	 * batchbuffer has been finished) the clean buffer objects would
74	 * be retired to the inactive list. Any dirty objects would be added
75	 * to the tail of the flushing list. So after processing the clean
76	 * active objects we need to emit a MI_FLUSH to retire the flushing
77	 * list, hence the retirement order of the flushing list is in
78	 * advance of the dirty objects on the active lists.
79	 *
80	 * The retirement sequence is thus:
81	 *   1. Inactive objects (already retired)
82	 *   2. Clean active objects
83	 *   3. Flushing list
84	 *   4. Dirty active objects.
85	 *
86	 * On each list, the oldest objects lie at the HEAD with the freshest
87	 * object on the TAIL.
88	 */
89
90	INIT_LIST_HEAD(&unwind_list);
91	if (mappable)
92		drm_mm_init_scan_with_range(&dev_priv->mm.gtt_space, min_size,
93					    alignment, 0,
94					    dev_priv->mm.gtt_mappable_end);
95	else
96		drm_mm_init_scan(&dev_priv->mm.gtt_space, min_size, alignment);
97
98	/* First see if there is a large enough contiguous idle region... */
99	list_for_each_entry(obj_priv, &dev_priv->mm.inactive_list, mm_list) {
100		if (mark_free(obj_priv, &unwind_list))
101			goto found;
102	}
103
104	/* Now merge in the soon-to-be-expired objects... */
105	list_for_each_entry(obj_priv, &dev_priv->mm.active_list, mm_list) {
106		/* Does the object require an outstanding flush? */
107		if (obj_priv->base.write_domain || obj_priv->pin_count)
108			continue;
109
110		if (mark_free(obj_priv, &unwind_list))
111			goto found;
112	}
113
114	/* Finally add anything with a pending flush (in order of retirement) */
115	list_for_each_entry(obj_priv, &dev_priv->mm.flushing_list, mm_list) {
116		if (obj_priv->pin_count)
117			continue;
118
119		if (mark_free(obj_priv, &unwind_list))
120			goto found;
121	}
122	list_for_each_entry(obj_priv, &dev_priv->mm.active_list, mm_list) {
123		if (! obj_priv->base.write_domain || obj_priv->pin_count)
124			continue;
125
126		if (mark_free(obj_priv, &unwind_list))
127			goto found;
128	}
129
130	/* Nothing found, clean up and bail out! */
131	list_for_each_entry(obj_priv, &unwind_list, evict_list) {
132		ret = drm_mm_scan_remove_block(obj_priv->gtt_space);
133		BUG_ON(ret);
134		drm_gem_object_unreference(&obj_priv->base);
135	}
136
137	/* We expect the caller to unpin, evict all and try again, or give up.
138	 * So calling i915_gem_evict_everything() is unnecessary.
139	 */
140	return -ENOSPC;
141
142found:
143	/* drm_mm doesn't allow any other other operations while
144	 * scanning, therefore store to be evicted objects on a
145	 * temporary list. */
146	INIT_LIST_HEAD(&eviction_list);
147	while (!list_empty(&unwind_list)) {
148		obj_priv = list_first_entry(&unwind_list,
149					    struct drm_i915_gem_object,
150					    evict_list);
151		if (drm_mm_scan_remove_block(obj_priv->gtt_space)) {
152			list_move(&obj_priv->evict_list, &eviction_list);
153			continue;
154		}
155		list_del(&obj_priv->evict_list);
156		drm_gem_object_unreference(&obj_priv->base);
157	}
158
159	/* Unbinding will emit any required flushes */
160	while (!list_empty(&eviction_list)) {
161		obj_priv = list_first_entry(&eviction_list,
162					    struct drm_i915_gem_object,
163					    evict_list);
164		if (ret == 0)
165			ret = i915_gem_object_unbind(&obj_priv->base);
166		list_del(&obj_priv->evict_list);
167		drm_gem_object_unreference(&obj_priv->base);
168	}
169
170	return ret;
171}
172
173int
174i915_gem_evict_everything(struct drm_device *dev, bool purgeable_only)
175{
176	drm_i915_private_t *dev_priv = dev->dev_private;
177	int ret;
178	bool lists_empty;
179
180	lists_empty = (list_empty(&dev_priv->mm.inactive_list) &&
181		       list_empty(&dev_priv->mm.flushing_list) &&
182		       list_empty(&dev_priv->render_ring.active_list) &&
183		       list_empty(&dev_priv->bsd_ring.active_list) &&
184		       list_empty(&dev_priv->blt_ring.active_list));
185	if (lists_empty)
186		return -ENOSPC;
187
188	/* Flush everything (on to the inactive lists) and evict */
189	ret = i915_gpu_idle(dev);
190	if (ret)
191		return ret;
192
193	BUG_ON(!list_empty(&dev_priv->mm.flushing_list));
194
195	return i915_gem_evict_inactive(dev, purgeable_only);
196}
197
198/** Unbinds all inactive objects. */
199int
200i915_gem_evict_inactive(struct drm_device *dev, bool purgeable_only)
201{
202	drm_i915_private_t *dev_priv = dev->dev_private;
203	struct drm_i915_gem_object *obj, *next;
204
205	list_for_each_entry_safe(obj, next,
206				 &dev_priv->mm.inactive_list, mm_list) {
207		if (!purgeable_only || obj->madv != I915_MADV_WILLNEED) {
208			int ret = i915_gem_object_unbind(&obj->base);
209			if (ret)
210				return ret;
211		}
212	}
213
214	return 0;
215}
216