util/benchmark/SimpleBenchmark.java

package appl.util.benchmark;

import java.awt.Rectangle;
import java.awt.image.DataBuffer;
import java.util.Random;

import appl.ext.XuluConfig;
import appl.parallel.data.splittable.SplittableLLProxyGrid;
import de.appl.data.LoadingException;
import de.appl.util.RasterMetaData;
import edu.bonn.xulu.plugin.io.grid.array.WritableGridArrayFactory;

/**
 * The algorithm simply iterates over a grid. The with and height can be
 * specified by the {@link XuluConfig} Property
 * <code>Benchmark.SimpleBench.gridwidth</code>. For each cell the average
 * over a neighborhood region is calculated. The neighborhoodRange can be
 * specified by <code>Benchmark.SimpleBench.neighborhood</code>. If the
 * algorithm reaches the end of the raster it starts again at (0,0). The rating
 * depends on the number of cells visited in the time (ms) specified by
 * <code>Benchmark.SimpleBench.time<code>. The number of cells is divided by
 * <code>Benchmark.SimpleBench.calibrator</code> and then given back as rating.
 * 
 * @author Dominik Appl
 */
public class SimpleBenchmark implements Benchmark {
        private SplittableLLProxyGrid inputGrid;

        int runningTime = 10000;

        private int gridwidth = 1000;

        private int neighborhoodRange;

        private double calibrator = 1;

        public int bench() {
                setUp();

                int cellCount = 0;
                long startTime = System.currentTimeMillis();
                Rectangle partition = new Rectangle(0, 0, inputGrid.getWidth(),
                                inputGrid.getHeight());
                boolean exit = false;
                for (int step = 0; exit == false; step++) {
                        // the overallsum is simply the sum over all elements
                        float overallSum = 0f;
                        for (int y = 0; y < inputGrid.getHeight(); y++)
                                for (int x = 0; x < inputGrid.getWidth(); x++) {
                                        if (System.currentTimeMillis() - startTime > runningTime)
                                                exit = true;
                                        else
                                                cellCount++;
                                        float tmp = inputGrid.getRasterSampleAsFloat(x, y);
                                        if (!Float.isNaN(tmp))
                                                overallSum += tmp;
                                        // the local sum is simply the sum over all elements in the
                                        // neighborhood
                                        float localSum = 0;
                                        // number of cells over which the sum is calculated
                                        int noOfCells = 0;
                                        // for each cell: calculate the sum of all neighbors
                                        for (int y2 = y - neighborhoodRange; y2 <= y
                                                        + neighborhoodRange; y2++)
                                                for (int x2 = x - neighborhoodRange; x2 <= x
                                                                + neighborhoodRange; x2++)
                                                        // check if the coordinates are valid (inside the
                                                        // grid and not NaN)
                                                        if (partition.contains(x2, y2))
                                                                if (!Float.isNaN(inputGrid
                                                                                .getRasterSampleAsFloat(x2, y2))) {
                                                                        localSum += inputGrid
                                                                                        .getRasterSampleAsFloat(x2, y2);
                                                                        noOfCells++;
                                                                }

                                }
                }
                return (int) (cellCount / calibrator);
        }

        /**
         * The method is used to load grids and to initialize the benchmarks
         * configuration.
         */
        private void setUp() {
                // read config
                int width = XuluConfig.getXuluConfig().getIntProperty(
                                "Benchmark.SimpleBench.gridwidth");
                if (width != 0)
                        this.gridwidth = width;
                // init running time
                int time = XuluConfig.getXuluConfig().getIntProperty(
                                "Benchmark.SimpleBench.runningtime");
                if (time != 0)
                        this.runningTime = time;
                // init calibrator
                double calibrator = XuluConfig.getXuluConfig().getDoubleProperty(
                                "Benchmark.SimpleBench.calibrator");
                if (calibrator != 0)
                        this.calibrator = calibrator;
                // init neighborhoodRange
                neighborhoodRange = XuluConfig.getXuluConfig().getIntProperty(
                                "Benchmark.SimpleBench.neighborhood");
                // create input Grid
                inputGrid = new SplittableLLProxyGrid(new WritableGridArrayFactory(),
                                new RasterMetaData(DataBuffer.TYPE_DOUBLE, gridwidth,
                                                gridwidth, 0, 0, 0, 0, 50, null));
                // load grid (so late loading has no influence on the calculation)
                try {
                        inputGrid.loadData();
                } catch (LoadingException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                // fill Grid with random Data
                Random rand = new Random();
                for (int y = 0; y < inputGrid.getHeight(); y++)
                        for (int x = 0; x < inputGrid.getWidth(); x++)
                                inputGrid.setGridSample(rand.nextDouble(), x, y);
        }

        public static void main(String[] args) {
                System.out.println("Current rating: " + new SimpleBenchmark().bench());
        }
}
1	mojays	2	package appl.util.benchmark;
2
3			import java.awt.Rectangle;
4			import java.awt.image.DataBuffer;
5			import java.util.Random;
6
7			import appl.ext.XuluConfig;
8			import appl.parallel.data.splittable.SplittableLLProxyGrid;
9	mojays	114	import de.appl.data.LoadingException;
10			import de.appl.util.RasterMetaData;
11	mojays	2	import edu.bonn.xulu.plugin.io.grid.array.WritableGridArrayFactory;
12
13			/**
14			* The algorithm simply iterates over a grid. The with and height can be
15			* specified by the {@link XuluConfig} Property
16			* <code>Benchmark.SimpleBench.gridwidth</code>. For each cell the average
17			* over a neighborhood region is calculated. The neighborhoodRange can be
18			* specified by <code>Benchmark.SimpleBench.neighborhood</code>. If the
19			* algorithm reaches the end of the raster it starts again at (0,0). The rating
20			* depends on the number of cells visited in the time (ms) specified by
21			* <code>Benchmark.SimpleBench.time<code>. The number of cells is divided by
22			* <code>Benchmark.SimpleBench.calibrator</code> and then given back as rating.
23			*
24			* @author Dominik Appl
25			*/
26			public class SimpleBenchmark implements Benchmark {
27			private SplittableLLProxyGrid inputGrid;
28
29			int runningTime = 10000;
30
31			private int gridwidth = 1000;
32
33			private int neighborhoodRange;
34
35			private double calibrator = 1;
36
37			public int bench() {
38			setUp();
39
40			int cellCount = 0;
41			long startTime = System.currentTimeMillis();
42			Rectangle partition = new Rectangle(0, 0, inputGrid.getWidth(),
43			inputGrid.getHeight());
44			boolean exit = false;
45			for (int step = 0; exit == false; step++) {
46			// the overallsum is simply the sum over all elements
47			float overallSum = 0f;
48			for (int y = 0; y < inputGrid.getHeight(); y++)
49			for (int x = 0; x < inputGrid.getWidth(); x++) {
50			if (System.currentTimeMillis() - startTime > runningTime)
51			exit = true;
52			else
53			cellCount++;
54			float tmp = inputGrid.getRasterSampleAsFloat(x, y);
55			if (!Float.isNaN(tmp))
56			overallSum += tmp;
57			// the local sum is simply the sum over all elements in the
58			// neighborhood
59			float localSum = 0;
60			// number of cells over which the sum is calculated
61			int noOfCells = 0;
62			// for each cell: calculate the sum of all neighbors
63			for (int y2 = y - neighborhoodRange; y2 <= y
64			+ neighborhoodRange; y2++)
65			for (int x2 = x - neighborhoodRange; x2 <= x
66			+ neighborhoodRange; x2++)
67			// check if the coordinates are valid (inside the
68			// grid and not NaN)
69			if (partition.contains(x2, y2))
70			if (!Float.isNaN(inputGrid
71			.getRasterSampleAsFloat(x2, y2))) {
72			localSum += inputGrid
73			.getRasterSampleAsFloat(x2, y2);
74			noOfCells++;
75			}
76
77			}
78			}
79			return (int) (cellCount / calibrator);
80			}
81
82			/**
83			* The method is used to load grids and to initialize the benchmarks
84			* configuration.
85			*/
86			private void setUp() {
87			// read config
88			int width = XuluConfig.getXuluConfig().getIntProperty(
89			"Benchmark.SimpleBench.gridwidth");
90			if (width != 0)
91			this.gridwidth = width;
92			// init running time
93			int time = XuluConfig.getXuluConfig().getIntProperty(
94			"Benchmark.SimpleBench.runningtime");
95			if (time != 0)
96			this.runningTime = time;
97			// init calibrator
98			double calibrator = XuluConfig.getXuluConfig().getDoubleProperty(
99			"Benchmark.SimpleBench.calibrator");
100			if (calibrator != 0)
101			this.calibrator = calibrator;
102			// init neighborhoodRange
103			neighborhoodRange = XuluConfig.getXuluConfig().getIntProperty(
104			"Benchmark.SimpleBench.neighborhood");
105			// create input Grid
106			inputGrid = new SplittableLLProxyGrid(new WritableGridArrayFactory(),
107			new RasterMetaData(DataBuffer.TYPE_DOUBLE, gridwidth,
108			gridwidth, 0, 0, 0, 0, 50, null));
109			// load grid (so late loading has no influence on the calculation)
110			try {
111			inputGrid.loadData();
112			} catch (LoadingException e) {
113			// TODO Auto-generated catch block
114			e.printStackTrace();
115			}
116			// fill Grid with random Data
117			Random rand = new Random();
118			for (int y = 0; y < inputGrid.getHeight(); y++)
119			for (int x = 0; x < inputGrid.getWidth(); x++)
120			inputGrid.setGridSample(rand.nextDouble(), x, y);
121			}
122
123			public static void main(String[] args) {
124			System.out.println("Current rating: " + new SimpleBenchmark().bench());
125			}
126			}