Navigation

← Previous Changeset
Next Changeset →

Changeset 201

Timestamp:

11/06/07 14:56:47 (1 year ago)

Author:

LeoD

Message:

Files:

branches/jobs/defend/Main.d (modified) (1 diff)
branches/jobs/defend/game/Game.d (modified) (4 diffs)
branches/jobs/defend/game/Jobs.d (added)
branches/jobs/defend/game/Mouse.d (modified) (1 diff)
branches/jobs/defend/game/hud/Hud.d (modified) (6 diffs)
branches/jobs/gen/core/JobSystem.d (modified) (11 diffs)
branches/jobs/gen/math/Misc.d (modified) (1 diff)
branches/jobs/gen/util/Profiler.d (modified) (1 diff)
branches/jobs/gen/util/ProfilingDisplay.d (modified) (6 diffs)
branches/jobs/windefend.cbp (modified) (1 diff)
trunk/defend/Main.d (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

branches/jobs/defend/Main.d

r200	r201
142	142	profile!("sleep")
143	143	({
144		sleep(1);
	144	//sleep(1);
	145	//Thread.yield();
	146
	147	if(!renderer.window.active)
	148	sleep(10);
145	149
146	150	// Limit FPS and calculate frame time

branches/jobs/defend/game/Game.d

r200	r201
10	10
11	11	import gen.core.JobSystem;
	12	import gen.renderer.All;
	13	import gen.sound.SoundSystem;
	14	import gen.input.Input;
	15	import gen.model.Model;
12	16	import gen.util.Wrapper;
13	17	import gen.util.Profiler;
…	…
15	19	import gen.util.Sprite2D;
16	20	import gen.util.ScreenDebugger;
17		~~import gen.renderer.All;~~
18		~~import gen.sound.SoundSystem;~~
19		~~import gen.input.Input;~~
20		~~import gen.model.Model;~~
21	21	import gen.math.Vector;
22	22	import gen.math.Matrix;
…	…
34	34	import defend.Config;
35	35	import defend.Camera;
36		import defend.game.Config;
37		import defend.game.Mouse;
	36	import defend.com.Gateway;
	37	import defend.terrain.Terrain;
	38	import defend.demo.Recorder;
	39	import defend.player.Manager;
	40	import defend.player.Info;
38	41	import defend.objects.Base;
39	42	import defend.objects.Manager;
40	43	import defend.objects.ObjectType;
	44	import defend.game.Jobs;
	45	import defend.game.Config;
	46	import defend.game.Mouse;
	47	import defend.game.hud.Hud;
41	48	import defend.game.net.All;
42	49	import defend.game.FakeGateway;
43		~~import defend.com.Gateway;~~
44		~~import defend.terrain.Terrain;~~
45		~~import defend.player.Manager;~~
46		~~import defend.player.Info;~~
47		~~import defend.game.hud.Hud;~~
48		~~import defend.demo.Recorder;~~
49	50
50	51	class Game : IGameState
…	…
282	283	void createJobs()
283	284	{
284		auto inputJob = jobSystem.addFrameJob("input", &jobInput);
285
286		auto simulationJob = jobSystem.addFrameJob("simulation", &gateway.runSimulation);
287		auto gatewayJob = jobSystem.addFrameJob("gateway", &gateway.update);
288		auto updateSyncsJob = jobSystem.addFrameJob("syncs", &jobUpdateSyncs);
289		//updateSyncsJob.dependOn(simulationJob);
	285	inputJob = jobSystem.addFrameJob("input", &jobInput);
	286	simulationJob = jobSystem.addFrameJob("simulation", &gateway.runSimulation);
	287	gatewayJob = jobSystem.addFrameJob("gateway", &gateway.update);
	288	hudJob = jobSystem.addFrameJob("hud", &jobUpdateHUD);
	289	mouseJob = jobSystem.addFrameJob("mouse", &jobUpdateMouse);
290	290
291		~~auto hudJob = jobSystem.addFrameJob("hud", &jobUpdateHUD~~);
292		~~//hudJob.dependOn(input~~Job);
	291	updateSyncsJob = jobSystem.addFrameJob("syncs", &jobUpdateSyncs);
	292	updateSyncsJob.dependOn(simulationJob);
293	293
294		auto mouseJob = jobSystem.addFrameJob("mouse", &jobUpdateMouse);
295		//mouseJob.dependOn(inputJob);
296
297		auto updateGraphJob = jobSystem.addFrameJob("graph", &jobUpdateGraph);
	294	updateGraphJob = jobSystem.addFrameJob("graph", &jobUpdateGraph);
298	295	updateGraphJob.dependOn(updateSyncsJob);
299	296
300		~~auto~~ renderJob = jobSystem.addFrameJob("render", &jobRender);
	297	renderJob = jobSystem.addFrameJob("render", &jobRender);
301	298	renderJob.dependOn(hudJob);
302	299	renderJob.dependOn(updateSyncsJob);
303		~~//renderJob.dependOn(simulationJob);~~
304		~~//renderJob.dependOn(gatewayJob);~~
305	300	renderJob.dependOn(updateGraphJob);
306	301	renderJob.dependOn(mouseJob);

branches/jobs/defend/game/Mouse.d

r198	r201
269	269	if(mousePos.y < renderer.height - HUD_HEIGHT \|\| areaSelection)
270	270	{
271		if(inputManager.keyPressed(KeyType.LeftButton) && !areaSelection)
	271	if(inputManager.keyPressedFirst(KeyType.LeftButton) && !areaSelection)
272	272	{
273	273	if(!inputManager.keyPressed(KeyType.LeftControl) \|\|

branches/jobs/defend/game/hud/Hud.d

r190	r201
5	5	import Float = tango.text.convert.Float;
6	6
	7	import gen.core.JobSystem;
7	8	import gen.util.FPS;
	9	import gen.util.Bind;
8	10	import gen.util.Bind;
9	11	import gen.util.JobHub;
10	12	import gen.util.Gamestates;
	13	import gen.util.Statistics;
11	14	import gen.util.ProfilingDisplay;
12		~~import gen.util.Statistics;~~
13	15	import gen.util.ScreenDebugger;
14	16	import gen.math.Vector;
…	…
23	25	import gen.font.Font;
24	26	import gen.font.FreeType;
25		~~import gen.util.Property;~~
26		~~import gen.util.Bind;~~
27	27	import gen.input.Input;
28	28
…	…
95	95	}
96	96
	97	JobInfo profilerJob;
	98
97	99	public:
98	100	IFont font, littlefont;
…	…
112	114	{
113	115	profiling = new ProfilingDisplay(littlefont);
	116	profilerJob = jobSystem.addPostFrameJob(&profiling.update);
	117	profilerJob.disable;
114	118	}
115	119
…	…
139	143	{
140	144	if(inputManager.keyPressedFirst(KeyType.P))
141		profile ~~= !profile~~;
	145	profilerJob.toggleEnabled();
142	146
143	147	if(inputManager.keyPressedFirst(KeyType.V))
…	…
171	175	font.write(10, 30, Vec3f(1), "Time: {}", frametime);
172	176
173		if(profile)
	177	if(profilerJob.enabled)
174	178	profiling.render();
175	179

branches/jobs/gen/core/JobSystem.d

r200	r201
7	7	import gen.util.Array;
8	8	import gen.util.Wrapper;
	9	import gen.util.Profiler;
9	10	import gen.util.Allocator;
10	11
…	…
22	23	void onAllocate()
23	24	{
	25	enabled = true;
	26	enableAfterFrame = false;
	27	disableAfterFrame = false;
24	28	name = "";
25	29	deps = [];
…	…
30	34	}
31	35
	36	bool enabled = true;
	37	bool enableAfterFrame = false;
	38	bool disableAfterFrame = false;
	39
32	40	char[] name;
33	41	JobInfo[] deps;
…	…
41	49	void reset()
42	50	{
	51	enableAfterFrame = false;
	52	disableAfterFrame = false;
43	53	depsResolved = 0;
44	54	done = false;
…	…
60	70	deps ~= other;
61	71	other.clientDeps ~= this;
	72	}
	73
	74	void toggleEnabled()
	75	{
	76	if(enabled)
	77	disable();
	78	else
	79	enable();
	80	}
	81
	82	void enable()
	83	{
	84	assert(!enabled);
	85	enableAfterFrame = true;
	86	}
	87
	88	void disable()
	89	{
	90	assert(enabled);
	91	disableAfterFrame = true;
	92	}
	93
	94	void checkEnable()
	95	{
	96	if(enableAfterFrame)
	97	{
	98	assert(!enabled);
	99	enabled = true;
	100	}
	101	else if(disableAfterFrame)
	102	{
	103	assert(enabled);
	104	enabled = false;
	105	}
62	106	}
63	107	}
…	…
67	111	private:
68	112	JobInfo[] frameJobs;
	113	JobInfo[] preFrameJobs;
	114	JobInfo[] postFrameJobs;
	115
69	116	uint oneShots; // number of one shot jobs this frame
70	117	uint jobsFinished;
	118	uint thisFrameToDo;
	119	bool inFrame;
	120
	121	ThreadInstance[] threads;
	122	Queue!(JobInfo) jobQueue;
	123
	124	void checkDeps(JobInfo job)
	125	{
	126	foreach(cdep; job.clientDeps)
	127	{
	128	if(!cdep.enabled)
	129	continue;
	130
	131	assert(!cdep.done, cdep.name ~ " already done");
	132	cdep.depsResolved++;
	133
	134	if(cdep.resolved)
	135	devolve(cdep);
	136	}
	137	}
	138
	139	void runJob(JobInfo job)
	140	{
	141	assert(job !is null);
	142	assert(job.dg !is null);
	143
	144	debug(jobs) synchronized(Stdout) Stdout("+ doing ")(info.name)(" from ")(cast(void*)this).newline;
	145
	146	job.dg();
	147
	148	job.done = true;
	149	jobsFinished++;
	150	}
71	151
72	152	enum ThreadState
…	…
101	181	{
102	182	state = ThreadState.Wait;
103
104		Thread.yield;
105
	183
106	184	//synchronized(Stdout) Stdout("waiting... and waiting...").newline;
107	185	//synchronized(mutex) condition.wait();
108	186	//synchronized(Stdout) Stdout("but not forever! noes!").newline;
	187
	188	Thread.yield;
109	189
110		while(!jobQueue.empty)
111		{
112		JobInfo info;
113
114		~~synchronized(jobQueue)~~
115		{
116		~~if(!jobQueue.empty~~)
	190	while(!jobQueue.empty)
	191	{
	192	profile!("worker thread")
	193	({
	194	JobInfo job;
	195
	196	synchronized(jobQueue)
117	197	{
118		info = jobQueue.pop;
119		state = ThreadState.Exec;
	198	if(!jobQueue.empty)
	199	{
	200	job = jobQueue.pop;
	201	state = ThreadState.Exec;
	202	}
	203	else
	204	return;
120	205	}
121		~~else~~
122		~~continue;~~
123		}
124
125		~~assert(info !is null);~~
126		~~assert(info.dg !is null);~~
127
128		~~debug(jobs) synchronized(Stdout) Stdout("+ doing ")(info.name)(" from ")(cast(void*)this).newline;~~
129
130		~~info.dg();~~
131
132		~~info.done = true;~~
133		~~jobsFinished++;~~
134
135		~~foreach(cdep; info.clientDeps)~~
136		{
137		~~assert(!cdep.done, cdep.name ~ " already done");~~
138		~~cdep.depsResolved++;~~
139	206
140		if(cdep.resolved)
141		{
142		//debug(jobs) synchronized(Stdout) Stdout("> ")(cdep.name, cdep.depsResolved, cdep.done).newline;
143
144		devolve(cdep);
145		}
146		}
147		}
	207	runJob(job);
	208	checkDeps(job);
	209	});
	210	}
148	211	}
149	212	}
…	…
155	218	}
156	219
157		~~ThreadInstance[] threads;~~
158		~~Queue!(JobInfo) jobQueue;~~
159
160	220	void devolve(JobInfo job)
161	221	{
	222	assert(job.enabled);
	223
162	224	//debug(jobs) synchronized(Stdout) Stdout("! devolving ")(job.name).newline;
163	225
…	…
169	231	foreach(thread; threads)
170	232	{
171		if(thread.state == ThreadState.Wait \|\| true)
172		{
	233	if(thread.state == ThreadState.Wait /\|\| true/)
	234	{
	235	//Thread.sleep(0.05);
173	236	synchronized(Stdout) Stdout("I'm notifying here, though...").newline;
174	237	synchronized(thread.mutex) thread.condition.notify();
…	…
183	246	jobQueue = new typeof(jobQueue)(2048);
184	247
185		uint numThreads = 2;
186		while(numThreads--)
187		threads ~= new ThreadInstance;
	248	uint numThreads = 1;
	249
	250	for(uint i = 0; i < numThreads; i++)
	251	threads ~= new ThreadInstance;
188	252	}
189	253
…	…
196	260	synchronized JobInfo addFrameJob(char[] name, JobType dg)
197	261	{
198		auto ~~info~~ = new JobInfo;
199		~~info~~.name = name;
200		~~info~~.dg = dg;
	262	auto job = new JobInfo;
	263	job.name = name;
	264	job.dg = dg;
201	265
202		frameJobs ~= ~~info~~;
	266	frameJobs ~= job;
203	267
204		return info;
205		}
206
207		JobInfo addOneShotJob(JobInfo info)
208		{
209		info.reset();
	268	return job;
	269	}
	270
	271	JobInfo addFrameJob(JobType dg)
	272	{
	273	return addFrameJob("", dg);
	274	}
	275
	276	JobInfo addOneShotJob(JobInfo job)
	277	{
	278	assert(inFrame);
	279
	280	job.reset();
210	281	oneShots++;
211		devolve(info);
212
213		return info;
	282	thisFrameToDo++;
	283	devolve(job);
	284
	285	return job;
	286	}
	287
	288	JobInfo addPostFrameJob(JobType dg)
	289	{
	290	auto job = new JobInfo;
	291	job.dg = dg;
	292
	293	postFrameJobs ~= job;
	294
	295	return job;
214	296	}
215	297
216	298	void startFrame()
217	299	{
218		oneShots = 0;
219		jobsFinished = 0;
220		jobQueue.reset;
221
222		foreach(job; frameJobs)
223		job.reset();
224
225		debug
226		{
	300	profile!("job.start")
	301	({
	302	oneShots = 0;
	303	jobsFinished = 0;
	304	thisFrameToDo = 0;
	305	jobQueue.reset;
	306
227	307	foreach(job; frameJobs)
228	308	{
229		assert(!job.done);
230		assert(job.depsResolved == 0);
231		}
232
233		foreach(thread; threads)
234		{
235		assert(thread.state == ThreadState.Wait);
236		}
237		}
238
239		foreach(job; frameJobs)
240		{
241		if(job.deps.length == 0)
242		devolve(job);
243		}
	309	job.checkEnable();
	310
	311	if(job.enabled)
	312	thisFrameToDo++;
	313
	314	job.reset();
	315	}
	316
	317	foreach(job; postFrameJobs)
	318	{
	319	job.checkEnable();
	320	job.reset();
	321	}
	322
	323	debug
	324	{
	325	foreach(job; frameJobs)
	326	{
	327	assert(!job.done);
	328	assert(job.depsResolved == 0);
	329	}
	330
	331	foreach(thread; threads)
	332	{
	333	assert(thread.state == ThreadState.Wait);
	334	}
	335	}
	336
	337	inFrame = true;
	338
	339	foreach(job; frameJobs)
	340	{
	341	if(job.enabled && job.deps.length == 0)
	342	devolve(job);
	343	}
	344
	345	if(threads.length == 0)
	346	{
	347	while(!jobQueue.empty)
	348	{
	349	auto job = jobQueue.pop();
	350	runJob(job);
	351	checkDeps(job);
	352	}
	353	}
	354	});
244	355	}
245	356
246	357	void endFrame()
247	358	{
248		while(true)
249		{
250		if(jobsFinished == frameJobs.length + oneShots)
251		{
252		assert(jobQueue.count == 0);
253
254		debug
255		{
256		foreach(job; frameJobs)
257		{
258		assert(job.resolved);
259		assert(job.done);
260		}
261		}
262
263		outer: while(true)
264		{
265		foreach(thread; threads)
	359	profile!("job.end")
	360	({
	361	while(jobsFinished != thisFrameToDo)
	362	Thread.yield();
	363
	364	inFrame = false;
	365	assert(jobsFinished == thisFrameToDo);
	366	assert(jobQueue.count == 0);
	367
	368	debug
	369	{
	370	foreach(job; frameJobs)
	371	{
	372	if(!job.enabled)
	373	continue;
	374
	375	assert(job.resolved);
	376	assert(job.done);
	377	}
	378	}
	379
	380	if(threads.length == 0 \|\| threads.length == 1)
	381	{
	382	foreach(job; postFrameJobs)
	383	{
	384	if(job.enabled)
	385	job.dg();
	386	}
	387	}
	388	else
	389	{
	390	foreach(job; postFrameJobs)
	391	{
	392	if(job.enabled)
	393	devolve(job);
	394	}
	395	}
	396
	397	while(jobQueue.count != 0)
	398	Thread.yield();
	399
	400	outer: while(true)
	401	{
	402	foreach(thread; threads)
	403	{
	404	if(thread.state != ThreadState.Wait)
266	405	{
267		if(thread.state != ThreadState.Wait)
268		{
269		Thread.sleep(0);
270		continue outer;
271		}
	406	Thread.yield();
	407	continue outer;
272	408	}
273
274		~~break;~~
275		}
276
277		debug(jobs) synchronized(Stdout) Stdout("- frame done").newline;
278
279		return;
280		}
281
282		~~Thread.sleep(0)~~;
283		}
	409	}
	410
	411	break;
	412	}
	413
	414	assert(jobQueue.count == 0);
	415
	416	debug(jobs) synchronized(Stdout) Stdout("- frame done").newline;
	417
	418	return;
	419	});
284	420	}
285	421	}

branches/jobs/gen/math/Misc.d

r149 r201

21 21 }
22 22
23 // From deadlock
23 24 void catmullRomInterp(T)(float t, T a, T b, T c, T d, inout T res) {
24 25 res = .5f * ((b * 2.f) +
branches/jobs/gen/util/Profiler.d

r200 r201

5 5 import gen.util.ThreadLocal;
6 6 import gen.util.HardwareTimer;
7
8 // From deadlock
7 9
8 10 struct ProfilingData

branches/jobs/gen/util/ProfilingDisplay.d

r187	r201
22	22	ulong time;
23	23	}
	24
	25	// From deadlock
24	26
25	27	class ProfilingDisplay
…	…
64	66	{
65	67	totalTime += data.time;
66		~~break~~;
	68	continue;
67	69	}
68	70	}
69	71
70		foreach(index, data; profilingData)
	72	foreach_reverse(index, data; profilingData)
71	73	{
72	74	if(data.calls == 0)
…	…
80	82	else
81	83	parent = &nodes[data.parent];
82
	84
83	85	node.sibling = parent.child;
84	86	parent.child = node;
…	…
104	106	return sum;
105	107	}
	108
	109	//subChildTime(&root);
106	110
107	111	foreach(index, data; profilingData)
…	…
128	132	static Vec3f[] colorRamp = [{x:1, y:1, z:1}, {x:1, y:0.6, z:0.4}, {x:1, y:0.4, z:0.3}, {x:1, y:0, z:0}];
129	133
130		uint offtop = 30;
	134	uint offTop = 30;
131	135
132		void recursion(Node* node, int offleft)
	136	void recursion(Node* node, int offLeft)
133	137	{
134	138	for(; node !is null; node = node.sibling)
…	…
137	141	{
138	142	Vec3f color;
139		catmullRomInterp(node.timeFrac * 3.f - 0.5f, colorRamp[0], colorRamp[1], colorRamp[2], colorRamp[3], color);
	143	catmullRomInterp(node.timeFrac * 3.f - .5f, colorRamp[0], colorRamp[1], colorRamp[2], colorRamp[3], color);
140	144
141		font.write(off~~left, offt~~op, color, "{}", node.text);
	145	font.write(offLeft, offTop, color, "{}", node.text);
142	146	}
143	147
144		offtop += font.maxHeight + 10;
145		recursion(node.child, offleft + indent);
	148	offTop += font.maxHeight + 10;
	149	recursion(node.child, offLeft + indent);
146	150	}
147	151	}

branches/jobs/windefend.cbp

r199	r201
113	113	<Unit filename="defend\game\FakeGateway.d" />
114	114	<Unit filename="defend\game\Game.d" />
	115	<Unit filename="defend\game\Jobs.d" />
115	116	<Unit filename="defend\game\Mouse.d">
116	117	<Option weight="1" />

trunk/defend/Main.d

r200	r201
171	171	profile!("sleep")
172	172	({
173		sleep(1);
	173	//sleep(1);
174	174
175	175	// Limit FPS and calculate frame time

r149	r201
21	21	}
22	22
	23	// From deadlock
23	24	void catmullRomInterp(T)(float t, T a, T b, T c, T d, inout T res) {
24	25	res = .5f * ((b * 2.f) +

r200	r201
5	5	import gen.util.ThreadLocal;
6	6	import gen.util.HardwareTimer;
	7
	8	// From deadlock
7	9
8	10	struct ProfilingData

Navigation

Changeset 201

Legend:

Download in other formats: