1: package com.aimms.aimmssdk.examples.performance;
2:
3: import com.aimms.aimmssdk.*;
4: import java.util.Date;
5: import org.slf4j.Logger;
6: import org.slf4j.LoggerFactory;
7:
8: /**
9: * This example demonstrates the performance difference between three ways to
10: * assign data to a set and to assign a 3 dimensional parameter on 50% of its
11: * domain positions.
12: */
13: class Performance {
14:
15: static private Logger logger = LoggerFactory.getLogger(Performance.class);
16: String m_Location;
17: String m_Project;
18: String[] m_Labels;
19: ISession m_Aimms = null;
20: ISetData m_SubSet = null;
21: IMultiDimData m_LargePar = null;
22: long m_StartTime = 0;
23:
24: public Performance(String aimmsLocation, String project, String[] labels) {
25: m_Location = aimmsLocation;
26: m_Project = project;
27: m_Labels = labels;
28: }
29:
30: /**
31: * The convenient way: Use a Tuple object constructed with labels to insert
32: * each data entry. This is inefficient due to the required string
33: * comparisons.
34: */
35: public void convenientAssignLabels() {
36:
37: openSessionAndData();
38: int setsize = m_Labels.length;
39:
40: start("Assign string labels using insert and the Tuple class");
41:
42: double value = 0.0;
43:
44: for (int i = 0; i < setsize; i += 2) { // a density of 50%, skip all odd positions of this dimension
45: for (int j = 0; j < setsize; ++j) {
46: for (int k = 0; k < setsize; ++k) {
47: ++value;
48: m_LargePar.insert(new Tuple(m_Labels[i], m_Labels[j], m_Labels[k]), value);
49: }
50: }
51: }
52: m_Aimms.updateData();
53:
54: stop();
55:
56: closeDataAndSession();
57: }
58:
59: /**
60: * Ordinals, ITuple and setValue: The more efficient way: Use ordinals to
61: * construct an ITuple and add the datapoint with it. Since the SDK uses the
62: * 'natural' Aimms ordering, the ordering of the data is not guaranteed to
63: * be the order in which the set data is supplied. So use ordinals with
64: * care. See also the section on "Set element ordering" in the Execution
65: * Efficiency Cookbook chapter in the Aimms Language Reference.
66: */
67: public void efficientAssignLabels() {
68:
69: openSessionAndData();
70: int setsize = m_Labels.length;
71:
72: start("Assign string labels first to the set and use the ITuple interface, ordinals and setValue to assign the values on the parameter");
73:
74:
75: for (int i = 0; i < setsize; ++i) {
76: m_SubSet.add(m_Labels[i]);
77: }
78:
79: m_Aimms.updateData(); // Update the set data to make label lookup faster.
80:
81: ITuple tup = m_LargePar.createTuple();
82: double value = 0.0;
83: try {
84: for (int i = 1; i <= setsize; i += 2) { // A density of 50%: skip al odd positions on this dimension.
85:
86: // Set each dimension only when it changes.
87: tup.getElement(0).setOrdinal(i);
88: for (int j = 1; j <= setsize; ++j) {
89: tup.getElement(1).setOrdinal(j);
90: for (int k = 1; k <= setsize; ++k) {
91: tup.getElement(2).setOrdinal(k);
92: ++value;
93:
94: m_LargePar.setValue(tup, value);
95: }
96: }
97: }
98:
99: m_Aimms.updateData();
100: } catch (AimmsRuntimeException ex) {
101: // setValue throws an AimmsRuntimeException if the elements of the tuple are not present in the index domain.
102: logger.error("Catched a runtime exception: {}", ex.getMessage());
103: m_Aimms.clearBuffers();
104:
105: } finally {
106:
107: stop();
108: closeDataAndSession();
109: }
110:
111:
112: }
113:
114: /**
115: * setValues: Efficient and convenient if the data to assign is dense. The
116: * setLabels (for sets) and setValues (for data) methods do allow for dense
117: * allocation of an identifier. The data will be added in the natural
118: * ordering of the domains, thus combining ease of use with efficiency.
119: */
120: public void denseAssignLabels() {
121:
122: openSessionAndData();
123: int setsize = m_Labels.length;
124: logger.info("setsize: {} ", setsize);
125: start("Assign string labels first to the set using setLabels and then use setValues on the IMultiDimData to assign the values to the parameter");
126:
127:
128: m_SubSet.setLabels(m_Labels);
129:
130: // UpdateData is not neccesary here because after the setLabels method the set is immediately up-to-date.
131:
132: double[] values = new double[setsize * setsize * setsize];
133:
134: // Whether a loop like this is neccesary depends on the source of the values.
135: double value = 0;
136: int pos = 0;
137: for (int i = 0; i < setsize; i += 2) {
138:
139: for (int j = 0; j < setsize; ++j) {
140: for (int k = 0; k < setsize; ++k) {
141: values[pos++] = ++value;
142: }
143: }
144: // Now insert a two dimensional slice with zero's (the default value), because this is a dense assign method but the data is not fully dense.
145: for (int z = 0; z < setsize * setsize; ++z) {
146: values[pos++] = 0;
147: }
148: }
149:
150: m_LargePar.setValues(values);
151:
152: m_Aimms.updateData();
153:
154: stop();
155:
156: closeDataAndSession();
157: }
158:
159: /**
160: * Slices: Efficient if the data to be assigned is sparse and distributed in
161: * a way slices can be defined. In this example multiple views are created
162: * that are all restricted on the same level on a single element. This
163: * reduces the dimension.
164: */
165: public void sliceAssignLabels() {
166:
167: openSessionAndData();
168: int setsize = m_Labels.length;
169:
170: start("Assign string labels first to the set using setLabels and then use setValues on IDataView slices of the IMultiDimData to assign the values to the parameter");
171:
172:
173: m_SubSet.setLabels(m_Labels);
174:
175:
176: double[] values = new double[setsize * setsize];
177:
178: // Create a filter to slice the parameter.
179: IFilter filter = m_LargePar.createFilter();
180:
181: double value = 0;
182: for (int i = 0; i < setsize; i += 2) {
183: // For each position of this dimension to which we will assign data, construct the filter to create a DataView.
184: // Notice the +=2, we only need views on the even positions.
185: filter.restrict(0, m_Labels[i]);
186: IDataView slice = m_LargePar.openView(filter);
187:
188: int pos = 0;
189: for (int j = 0; j < setsize; ++j) {
190: for (int k = 0; k < setsize; ++k) {
191: values[pos++] = ++value;
192: }
193: }
194: slice.setValues(values);
195: }
196:
197: m_Aimms.updateData();
198:
199: stop();
200:
201: closeDataAndSession();
202: }
203:
204: /**
205: * Filtering by call domain: Efficient if the data is sparse and an
206: * appropriate subset is available to filter with.
207: */
208: public void filteredAssignLabels() {
209:
210: openSessionAndData();
211: int setsize = m_Labels.length;
212:
213: start("Assign string labels first to the set using setLabels and use setValues on an IDataView filtered by a subset to assign the values on the parameter");
214:
215: m_SubSet.setLabels(m_Labels);
216:
217: // Open a subset on the domainset to use as a call domain on the level to restrict.
218: ISetData subsubset = m_Aimms.openSet("SubSubSet");
219: IElement element = m_SubSet.createElement();
220:
221: for (int o = 1; o <= setsize; o += 2) {
222: element.setOrdinal(o);
223: subsubset.add(element);
224: }
225: m_Aimms.updateData();
226:
227: double[] values = new double[setsize / 2 * setsize * setsize];
228:
229: // Create a filter to slice the parameter.
230: IFilter filter = m_LargePar.createFilter();
231: filter.restrict(0, subsubset);
232: IDataView view = m_LargePar.openView(filter);
233:
234:
235: double value = 0;
236: int pos = 0;
237: for (int i = 0; i < setsize; i += 2) {
238: for (int j = 0; j < setsize; ++j) {
239: for (int k = 0; k < setsize; ++k) {
240: values[pos++] = ++value;
241: }
242: }
243: }
244: view.setValues(values);
245:
246: m_Aimms.updateData();
247:
248: stop();
249:
250: subsubset.close();
251: closeDataAndSession();
252:
253:
254: }
255:
256: // Helper functions
257: private void openSessionAndData() {
258: m_Aimms = null;
259: m_Aimms = AIMMS.openSession(m_Location, m_Project);
260: if (m_Aimms == null) {
261: return;
262: }
263: m_SubSet = m_Aimms.openSet("LargeSubSet");
264: m_LargePar = m_Aimms.openMultiDim("LargePar1");
265: }
266:
267: private void closeDataAndSession() {
268: m_LargePar.close();
269: m_SubSet.close();
270: m_Aimms.close();
271: }
272:
273: private void start(String testDescription) {
274: logger.info("Start Running {}...", testDescription);
275: m_StartTime = new Date().getTime();
276: }
277:
278: private void stop() {
279: long stop = new Date().getTime();
280: long dif = stop - m_StartTime;
281: logger.info("This took {} milliseconds", dif);
282: logger.info("");
283: }
284: }
