1
=== modified file 'src/server/compositor/switching_bundle.cpp'
2
--- src/server/compositor/switching_bundle.cpp	2014-03-06 05:29:00 +0000
3
+++ src/server/compositor/switching_bundle.cpp	2014-03-06 12:38:10 +0000
4
@@ -182,6 +182,29 @@
5
182
    return ring[slot].buf;
182
    return ring[slot].buf;
6
183
}
183
}
7
184
184
8
185
inline
9
186
bool mc::SwitchingBundle::client_buffers_available(std::unique_lock<std::mutex> const& /*lock*/)
10
187
{
11
188
    /*
12
189
     * Even if there are free buffers available, we might wish to still
13
190
     * wait. This is so we don't touch (hence allocate) a third or higher
14
191
     * buffer until/unless it's absolutely necessary. It becomes necessary
15
192
     * only when framedropping (above) or with overlapping compositors
16
193
     * (like with bypass).
17
194
     * The performance benefit of triple buffering is usually minimal,
18
195
     * but always uses 50% more memory. So try to avoid it when possible.
19
196
     */
20
197
21
198
    int min_free =
22
199
#if 0  // FIXME: This memory optimization breaks timing tests
23
200
        (nbuffers > 2 && !overlapping_compositors) ?  nbuffers - 1 : 1;
24
201
#else
25
202
        1;
26
203
#endif
27
204
28
205
    return nfree() >= min_free;
29
206
}
30
207
31
185
void mc::SwitchingBundle::client_acquire(std::function<void(graphics::Buffer* buffer)> complete)
208
void mc::SwitchingBundle::client_acquire(std::function<void(graphics::Buffer* buffer)> complete)
32
186
{
209
{
33
187
    std::unique_lock<std::mutex> lock(guard);
210
    std::unique_lock<std::mutex> lock(guard);
34
@@ -199,24 +222,7 @@
35
199
    }
222
    }
36
200
    else
223
    else
37
201
    {
224
    {
56
202
        /*
225
        if (!client_buffers_available(lock))
39
203
         * Even if there are free buffers available, we might wish to still
40
204
         * wait. This is so we don't touch (hence allocate) a third or higher
41
205
         * buffer until/unless it's absolutely necessary. It becomes necessary
42
206
         * only when framedropping (above) or with overlapping compositors
43
207
         * (like with bypass).
44
208
         * The performance benefit of triple buffering is usually minimal,
45
209
         * but always uses 50% more memory. So try to avoid it when possible.
46
210
         */
47
211
48
212
        int min_free =
49
213
#if 0  // FIXME: This memory optimization breaks timing tests
50
214
            (nbuffers > 2 && !overlapping_compositors) ?  nbuffers - 1 : 1;
51
215
#else
52
216
            1;
53
217
#endif
54
218
55
219
        if (nfree() < min_free)
57
220
            return;
226
            return;
58
221
    }
227
    }
59
222
228
60
@@ -362,7 +368,8 @@
61
362
            ncompositors--;
368
            ncompositors--;
62
363
        }
369
        }
63
364
370
65
365
        if (client_acquire_todo) complete_client_acquire(std::move(lock));
371
        if (client_buffers_available(lock) && client_acquire_todo)
66
372
            complete_client_acquire(std::move(lock));
67
366
    }
373
    }
68
367
}
374
}
69
368
375
70
369
376
71
=== modified file 'src/server/compositor/switching_bundle.h'
72
--- src/server/compositor/switching_bundle.h	2014-03-06 05:29:00 +0000
73
+++ src/server/compositor/switching_bundle.h	2014-03-06 12:38:10 +0000
74
@@ -84,6 +84,7 @@
75
84
84
76
85
    const std::shared_ptr<graphics::Buffer> &alloc_buffer(int slot);
85
    const std::shared_ptr<graphics::Buffer> &alloc_buffer(int slot);
77
86
    void complete_client_acquire(std::unique_lock<std::mutex> lock);
86
    void complete_client_acquire(std::unique_lock<std::mutex> lock);
78
87
    bool client_buffers_available(std::unique_lock<std::mutex> const& lock);
79
87
    struct SharedBuffer
88
    struct SharedBuffer
80
88
    {
89
    {
81
89
        std::shared_ptr<graphics::Buffer> buf;
90
        std::shared_ptr<graphics::Buffer> buf;
Reviewer	Review Type	Date Requested	Status
Daniel van Vugt			Approve on 2014-03-10
PS Jenkins bot (community)	continuous-integration		Approve on 2014-03-06
Alexandros Frantzis (community)		2014-03-06	Needs Fixing on 2014-03-06
Review via email: mp+209662@code.launchpad.net
1	=== modified file 'src/server/compositor/switching_bundle.cpp'
2	--- src/server/compositor/switching_bundle.cpp 2014-03-06 05:29:00 +0000
3	+++ src/server/compositor/switching_bundle.cpp 2014-03-06 12:38:10 +0000
4	@@ -182,6 +182,29 @@
5	182	return ring[slot].buf;	182	return ring[slot].buf;
6	183	}	183	}
7	184		184
8			185	inline
9			186	bool mc::SwitchingBundle::client_buffers_available(std::unique_lock<std::mutex> const& /lock/)
10			187	{
11			188	/*
12			189	* Even if there are free buffers available, we might wish to still
13			190	* wait. This is so we don't touch (hence allocate) a third or higher
14			191	* buffer until/unless it's absolutely necessary. It becomes necessary
15			192	* only when framedropping (above) or with overlapping compositors
16			193	* (like with bypass).
17			194	* The performance benefit of triple buffering is usually minimal,
18			195	* but always uses 50% more memory. So try to avoid it when possible.
19			196	*/
20			197
21			198	int min_free =
22			199	#if 0 // FIXME: This memory optimization breaks timing tests
23			200	(nbuffers > 2 && !overlapping_compositors) ? nbuffers - 1 : 1;
24			201	#else
25			202	1;
26			203	#endif
27			204
28			205	return nfree() >= min_free;
29			206	}
30			207
31	185	void mc::SwitchingBundle::client_acquire(std::function<void(graphics::Buffer* buffer)> complete)	208	void mc::SwitchingBundle::client_acquire(std::function<void(graphics::Buffer* buffer)> complete)
32	186	{	209	{
33	187	std::unique_lock<std::mutex> lock(guard);	210	std::unique_lock<std::mutex> lock(guard);
34	@@ -199,24 +222,7 @@
35	199	}	222	}
36	200	else	223	else
37	201	{	224	{
56	202	/*	225	if (!client_buffers_available(lock))
39	203	* Even if there are free buffers available, we might wish to still
40	204	* wait. This is so we don't touch (hence allocate) a third or higher
41	205	* buffer until/unless it's absolutely necessary. It becomes necessary
42	206	* only when framedropping (above) or with overlapping compositors
43	207	* (like with bypass).
44	208	* The performance benefit of triple buffering is usually minimal,
45	209	* but always uses 50% more memory. So try to avoid it when possible.
46	210	*/
47	211
48	212	int min_free =
49	213	#if 0 // FIXME: This memory optimization breaks timing tests
50	214	(nbuffers > 2 && !overlapping_compositors) ? nbuffers - 1 : 1;
51	215	#else
52	216	1;
53	217	#endif
54	218
55	219	if (nfree() < min_free)
57	220	return;	226	return;
58	221	}	227	}
59	222		228
60	@@ -362,7 +368,8 @@
61	362	ncompositors--;	368	ncompositors--;
62	363	}	369	}
63	364		370
65	365	if (client_acquire_todo) complete_client_acquire(std::move(lock));	371	if (client_buffers_available(lock) && client_acquire_todo)
66			372	complete_client_acquire(std::move(lock));
67	366	}	373	}
68	367	}	374	}
69	368		375
70	369		376
71	=== modified file 'src/server/compositor/switching_bundle.h'
72	--- src/server/compositor/switching_bundle.h 2014-03-06 05:29:00 +0000
73	+++ src/server/compositor/switching_bundle.h 2014-03-06 12:38:10 +0000
74	@@ -84,6 +84,7 @@
75	84		84
76	85	const std::shared_ptr<graphics::Buffer> &alloc_buffer(int slot);	85	const std::shared_ptr<graphics::Buffer> &alloc_buffer(int slot);
77	86	void complete_client_acquire(std::unique_lock<std::mutex> lock);	86	void complete_client_acquire(std::unique_lock<std::mutex> lock);
78			87	bool client_buffers_available(std::unique_lock<std::mutex> const& lock);
79	87	struct SharedBuffer	88	struct SharedBuffer
80	88	{	89	{
81	89	std::shared_ptr<graphics::Buffer> buf;	90	std::shared_ptr<graphics::Buffer> buf;