glaville / mcmas

Blame view

src/mior/model/OCLMiorModel.java 3.82 KB
edit raw normal view history
1b1e928cc   glaville   initial import of... 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
  package mior.model;
  
  import java.util.Random;
  
  import mcmas.core.MCM;
  import mcmas.core.MCMCommandQueue;
  import mcmas.core.MCMCommandQueueProperty;
  import mcmas.core.MCMContext;
  import mcmas.core.MCMEvent;
  import mcmas.core.MCMKernel;
  import mcmas.core.MCMMem;
  import mcmas.core.MCMProgram;
  import mcmas.core.MCMUtils;
  
  import org.jocl.Pointer;
  
  
  public class OCLMiorModel extends SimpleMiorModel {
  	
  	private MCMContext 		context;
  	private MCMProgram 		program;
  	private MCMCommandQueue queue;
  	
  	private MCMKernel		topoKernel;
  	private MCMKernel		liveKernel;
  	
  	private MCMMem     		mmMem;
  	private MCMMem     		omMem;
  	private MCMMem     		associationsMem;
  	private MCMMem     		worldMem;
  	
  	private MCMMem          omIndexesMem;
  	private final Random    rand;
  	
  	private final static String MODEL_SOURCE = "kernels/mior_model.cl";
  	
  	public OCLMiorModel(MiorWorld world) {
  		super(world);
  		this.rand = new Random();
  		
  		this.context = new MCMContext();
  		this.queue = context.createCommandQueue(MCMCommandQueueProperty.ENABLE_PROFILING);
  		this.program = MCMUtils.compileFile(context, MODEL_SOURCE);
  		
  		this.topoKernel = program.createKernel("topology");
  		this.liveKernel = program.createKernel("live");
  		
  		this.mmMem = context.newBuffer().Using(mmList).b();
  		this.omMem = context.newBuffer().Using(omList).b();
  		this.associationsMem = context.newBuffer().Size(associations.length, MCM.INT).b();
  		this.worldMem = context.newBuffer().Using(world).b();
  		
  		this.omIndexesMem = context.newBuffer().Size(omList.length * mmList.length, MCM.INT).b();
  	}
  	
  	
  	@Override
  	protected void resetImpl() {
  		super.resetImpl();
  		queue.enqueueWriteBuffer(mmMem, mmList, 0, mmMem.getSize());
  		queue.enqueueWriteBuffer(omMem, omList, 0, omMem.getSize());
  		queue.enqueueWriteBuffer(associationsMem, Pointer.to(associations), 0, associationsMem.getSize());
  		queue.enqueueWriteBuffer(worldMem, new MiorWorld[] { world }, 0, worldMem.getSize());
  	}
  	
  	@Override
  	public void doTopologyImpl() {
  		topoKernel.setArguments(mmMem, omMem, associationsMem, worldMem);
  		
  		/*
  		OCLEvent event = queue.enqueueKernel(
  				topoKernel, 2,
  				new long[] { 0, 0 },
  				new long[] { mmList.length, omList.length },
  				new long[] { 1, 1 }
  		);*/
  		
  		MCMEvent event = queue.enqueueKernel(topoKernel, 2, new long[] { nbMM, nbOM });
  		
  		MCMEvent.waitFor(event);
  		MCMUtils.printEventStats("topology", event);
  		
  		if (! isBatchModeEnabled()) {
  			queue.blockingReadBuffer(associationsMem, Pointer.to(associations), 0, associationsMem.getSize());
  		}
  	}
  	
  	@Override
  	public void doLiveImpl() {
  		if (isRandomEnabled()) {
  			liveKernel.setArguments(mmMem, omMem, associationsMem, worldMem, omIndexesMem, rand.nextLong());
  		} else {
  			liveKernel.setArguments(mmMem, omMem, associationsMem, worldMem, omIndexesMem, 0L);
  		}
  		
  		MCMEvent event = queue.enqueue1DKernel(liveKernel, nbMM);
  		MCMEvent.waitFor(event);
  		
  		MCMUtils.printEventStats("live", event);
  		
  		if (! isBatchModeEnabled()) {
  			queue.blockingReadBuffer(mmMem, mmList, 0, mmMem.getSize());
  			queue.blockingReadBuffer(omMem, omList, 0, omMem.getSize());
  			queue.blockingReadBuffer(associationsMem, Pointer.to(associations), 0, associationsMem.getSize());
  		}
  		
  		queue.blockingReadBuffer(worldMem, new MiorWorld[] {world}, 0, worldMem.getSize());
  	}
  	
  	@Override
  	protected void onSimulationFinished() {
  		if (isBatchModeEnabled()) {
  			queue.blockingReadBuffer(mmMem, mmList, 0, mmMem.getSize());
  			queue.blockingReadBuffer(omMem, omList, 0, omMem.getSize());
  			queue.blockingReadBuffer(associationsMem, Pointer.to(associations), 0, associationsMem.getSize());
  		}
  		
  		super.onSimulationFinished();
  	}
  	
  	@Override
  	protected void releaseImpl() {
  		associationsMem.release();
  		worldMem.release();
  		mmMem.release();
  		omMem.release();
  		
  		liveKernel.release();
  		topoKernel.release();
  		program.release();
  		queue.release();
  		context.release();
  	}
  	
  }