bundles/org.simantics.databoard/testcases/org/simantics/databoard/tests/PerformanceTest.java

   1 /*******************************************************************************
   2  *  Copyright (c) 2010 Association for Decentralized Information Management in
   3  *  Industry THTH ry.
   4  *  All rights reserved. This program and the accompanying materials
   5  *  are made available under the terms of the Eclipse Public License v1.0
   6  *  which accompanies this distribution, and is available at
   7  *  http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  *  Contributors:
  10  *      VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.databoard.tests;
  13
  14 import java.io.File;
  15 import java.util.TreeMap;
  16
  17 import org.simantics.databoard.Accessors;
  18 import org.simantics.databoard.Bindings;
  19 import org.simantics.databoard.accessor.file.FileMapAccessor;
  20 import org.simantics.databoard.accessor.file.FileRecordAccessor;
  21 import org.simantics.databoard.accessor.file.FileVariantAccessor;
  22 import org.simantics.databoard.annotations.Optional;
  23 import org.simantics.databoard.binding.Binding;
  24 import org.simantics.databoard.binding.util.RandomValue;
  25 import org.simantics.databoard.type.Datatype;
  26 import org.simantics.databoard.type.LongType;
  27
  28 public class PerformanceTest {
  29
  30         public static class FloatSample {
  31                 public float value;
  32         }
  33
  34         public static class IntegerSample {
  35                 public int value;
  36         }
  37
  38         public static class FloatRecord {
  39                 public Object id;
  40
  41                 public TreeMap<String, String> displayNames;
  42
  43                 public SamplingParameters samplingParameters;
  44
  45                 public TreeMap<Long, FloatSample> samples;
  46         }
  47
  48         public static class IntegerRecord {
  49                 public Object id;
  50
  51                 public TreeMap<String, String> displayNames;
  52
  53                 public SamplingParameters samplingParameters;
  54
  55                 public TreeMap<Long, IntegerSample> samples;
  56         }
  57
  58         public static class SamplingParameters {
  59                 public @Optional Object deadband;
  60                 public @Optional Object interval;
  61         }
  62
  63         public static class LocalizedText {
  64                 public String locale;
  65                 public String text;
  66         }
  67
  68         public static void main(String[] args) throws Exception {
  69                 // Init
  70                 Datatype time_type                                      = new LongType("ms");
  71                 Binding time_binding                            = Bindings.getBinding( Long.class );
  72                 Binding float_sample_binding            = Bindings.getBinding( FloatSample.class);
  73                 Binding integer_sample_binding          = Bindings.getBinding( IntegerSample.class);
  74                 Binding float_record_binding            = Bindings.getBinding( FloatRecord.class );
  75                 Binding integer_record_binding          = Bindings.getBinding( IntegerRecord.class );
  76
  77                 // Test variables
  78                 int var_count = 1000;
  79                 long interval = 10;
  80                 long duration = 10000000;//10*60*60*1000; // ms
  81                 int  block_size = 100;
  82                 long steps = duration / interval;
  83                 long iterations = steps / block_size;
  84                 System.out.println("Performance Test");
  85                 System.out.println(" o variables = "+var_count);
  86                 System.out.println(" o duration = "+duration/1000+" s");
  87                 System.out.println(" o interval = "+interval+" ms");
  88                 System.out.println(" o samples_in_write = "+block_size);
  89                 System.out.println(" o At each step, a single sample is appended.");
  90
  91
  92                 // Prepare files
  93                 System.out.println(" o Initialization.");
  94                 FileRecordAccessor[] variables = new FileRecordAccessor[var_count];
  95                 FileMapAccessor[] maps = new FileMapAccessor[var_count];
  96                 for (int i=0; i<var_count; i++) {
  97                         // Create a file
  98                         // <variableId>.dat
  99                         File file = File.createTempFile("variable"+i, ".tmp");
 100                         file.deleteOnExit();
 101                         FileVariantAccessor fa = Accessors.createFile(file);
 102
 103                         // Make it a record
 104                         Binding record_binding = i<var_count/2 ? float_record_binding : integer_record_binding;
 105                         Object empty_record = record_binding.createDefault();
 106                         fa.setContentValue(record_binding, empty_record);
 107
 108                         // Get accessors to the record and its field "samples"
 109                         FileRecordAccessor ra = fa.getContentAccessor();
 110                         FileMapAccessor map = ra.getFieldAccessor("samples");
 111                         variables[i] = ra;
 112                         maps[i] = map;
 113                 }
 114
 115 //              System.out.println(" o variable1 = "+variables[0].type().toString());
 116
 117                 RandomValue rv = new RandomValue();
 118                 FloatSample block1[] = new FloatSample[block_size];
 119                 IntegerSample block2[] = new IntegerSample[block_size];
 120                 for (int i=0; i<block_size; i++) {
 121                         block1[i] = new FloatSample();
 122                         block2[i] = new IntegerSample();
 123                 }
 124                 Long times[] = new Long[block_size];
 125
 126                 long startTime = System.currentTimeMillis();
 127                 long reportTime = startTime;
 128                 Long simulationTime = 0L;
 129                 for (int i=0; i<iterations; i++) {
 130
 131                         for (int vi=0; vi<var_count; vi++) {
 132                                 FileMapAccessor map = maps[vi];
 133                                 Binding sample_binding = vi<var_count/2 ? float_sample_binding : integer_sample_binding;
 134
 135                                 // Create [block_size] samples
 136                                 if (sample_binding == float_sample_binding) {
 137                                         // Create [block_size] random float samples
 138                                         for (int j=0; j<block_size; j++) {
 139                                                 block1[j].value = rv.getRandom().nextFloat();
 140                                                 times[j] = simulationTime + j * interval;
 141                                         }
 142                                         // Append [block_size] float samples
 143                                         map.putAllNoflush(time_binding, sample_binding, times, block1);
 144                                 } else {
 145                                         // Create [block_size] random integer samples
 146                                         for (int j=0; j<block_size; j++) {
 147                                                 block2[j].value = rv.getRandom().nextInt();
 148                                                 times[j] = simulationTime + j * interval;
 149                                         }
 150                                         // Append [block_size] integer samples
 151                                         map.putAllNoflush(time_binding, sample_binding, times, block2);
 152                                 }
 153
 154                         }
 155
 156                         // Buffers are flushed every 1000 steps
 157                         long currentTime = System.currentTimeMillis();
 158                         if (currentTime - reportTime > 1000L) {
 159                                 System.out.println("Report:");
 160                                 System.out.println(" o Simulation Time: "+simulationTime/1000+" s");
 161                                 System.out.println(" o Time elapsed: "+ (currentTime - startTime)/1000 + " s" );
 162                                 System.out.println(" o Samples in a variable: "+ maps[0].size());
 163 //                              for (int vi=0; vi<var_count; vi++) variables[vi].flush();
 164
 165                                 reportTime = currentTime;
 166                         }
 167
 168                         simulationTime += interval*block_size;
 169                 }
 170
 171                 System.out.println("Simulation finished.");
 172
 173                 // Close files
 174                 System.out.println(" o Closing files.");
 175                 for (int vi=0; vi<var_count; vi++) {
 176                         variables[vi].flush();
 177                         variables[vi].close();
 178                         variables[vi].file().delete();
 179                 }
 180
 181                 // Measure time
 182                 long endTime = System.currentTimeMillis();
 183                 long elapsedTime = endTime - startTime;
 184                 System.out.println(" o Elapsed Time: "+elapsedTime+" ms");
 185
 186         }
 187
 188 }
 189