glaville / mcmas

Blame view

src/mior/model/ModelFactory.java 3.2 KB
edit raw normal view history
89f70c1ec   glaville   import current mc... 
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
 
  package mior.model;
  
  import mior.model.dist.LinearDistribution;
  import mior.model.dist.StaticDistribution;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  public class ModelFactory {
  	
  	private boolean batchModeEnabled;
  	private boolean randomizePopulations;
  	private int groupSize;
  	private int blockSize;
  	
  	private final static Logger logger = LoggerFactory.getLogger(ModelFactory.class);
  	
  	public ModelFactory() {
  		this.batchModeEnabled = true;
  		this.randomizePopulations = false;
  		this.groupSize = 1;
  		this.blockSize = -1;
  	}
  	
  	public IMiorModel createModel(int nbMM, int nbOM, int scale, int modelVersion) {
  		final MiorWorld world = new MiorWorld(nbMM, nbOM, scale);
  		final IMiorModel model;
  		
  		logger.info("Using model version v" + modelVersion);
  		
  		if (modelVersion <= 5 && groupSize > 1) {
  			throw new UnsupportedOperationException("Mior implementation "
  					+ modelVersion + " does not support this degree ("
  					+ groupSize + ") of parallelism.");
  		}
  		
  		switch (modelVersion) {
  		case 0:
  			model = new CPUMiorModel(world);
  			break;
  		case 1:
  			model = new OCLMiorModel(world);
  			break;
  		case 2:
  			model = new OCLMiorModel2(world);
  			break;
  		case 3:
  			model = new OCLCSRModel(world, false);
  			break;
  		case 4:
  			model = new OCLCSRModel(world, true);
  			break;
  		case 5:
  			model = new OCLCSRModel2(world);
  			break;
  		case 6:
  			model = new OCLParaCSRModel2(nbMM, nbOM, groupSize);
  			if (blockSize != -1) model.setBlockSize(blockSize);
  			break;
  		case 7:
  			if (randomizePopulations) {
  				model = new OCLParaCSRModel3(nbMM, nbOM, groupSize, new LinearDistribution(nbMM, nbOM, 0.3));
  			} else {
  				model = new OCLParaCSRModel3(nbMM, nbOM, groupSize, new StaticDistribution(nbMM, nbOM));
  			}
  			if (blockSize != -1) model.setBlockSize(blockSize);
  			break;
  		case 8:
  			if (randomizePopulations) {
  				model = new OCLParaCSRModelAlt(nbMM, nbOM, groupSize, new LinearDistribution(nbMM, nbOM, 0.3));
  			} else {
  				model = new OCLParaCSRModelAlt(nbMM, nbOM, groupSize, new StaticDistribution(nbMM, nbOM));
  			}
  			if (blockSize != -1) model.setBlockSize(blockSize);
  			break;
  		case 9:
  			if (randomizePopulations) {
  				model = new OCLParaCSRModel4(nbMM, nbOM, groupSize, new LinearDistribution(nbMM, nbOM, 0.3));
  			} else {
  				model = new OCLParaCSRModel4(nbMM, nbOM, groupSize, new StaticDistribution(nbMM, nbOM));
  			}
  			if (blockSize != -1) model.setBlockSize(blockSize);
  			break;
  		default:
  			throw new RuntimeException("Invalid model version: " + modelVersion);
  		}
  		
  		model.setBatchModeEnabled(batchModeEnabled);
  		model.setRandomEnabled(randomizePopulations);
  		
  		return model;
  	} 
  	
  	public void setBatchModeEnabled(boolean batchModeEnabled) {
  		this.batchModeEnabled = batchModeEnabled;
  	}
  	
  	public boolean isBatchModeEnabled() {
  		return batchModeEnabled;
  	}
  	
  	public void setRandomEnabled(boolean randomEnabled) {
  		this.randomizePopulations = randomEnabled;
  	}
  	
  	public boolean isRandomEnabled() {
  		return randomizePopulations;
  	}
  	
  	public void setBlockSize(int blockSize) {
  		this.blockSize = blockSize;
  	}
  	
  	public int getBlockSize() {
  		return blockSize;
  	}
  	
  	public void setGroupSize(int kernelSize) {
  		this.groupSize = kernelSize;
  	}
  	
  	public int getGroupSize() {
  		return groupSize;
  	}
  	
  }