diff options
Diffstat (limited to 'test/ImageViewerPerfTest.java')
| -rwxr-xr-x | test/ImageViewerPerfTest.java | 240 |
1 files changed, 240 insertions, 0 deletions
diff --git a/test/ImageViewerPerfTest.java b/test/ImageViewerPerfTest.java new file mode 100755 index 000000000..6f758164c --- /dev/null +++ b/test/ImageViewerPerfTest.java @@ -0,0 +1,240 @@ +// ImageViewerPerfTest.java +// ----------------------- +// part of YaCy +// (C) by Michael Peter Christen; mc@yacy.net +// first published on http://www.anomic.de +// Frankfurt, Germany, 2006 +// created 03.04.2006 +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +import java.io.File; +import java.io.FileOutputStream; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +import javax.imageio.ImageIO; +import javax.imageio.stream.ImageInputStream; + +import net.yacy.cora.document.id.DigestURL; +import net.yacy.cora.util.ConcurrentLog; +import net.yacy.peers.graphics.EncodedImage; +import net.yacy.server.serverObjects; + + + +/** + * Test to measure image render performance by + * + * @author luc + * + */ +public class ImageViewerPerfTest extends ImageViewerTest { + + /** Default minimum measurement time */ + private static final int DEFAULT_MIN_MEASURE_TIME = 10; + + /** Minimum measurement time */ + private int minMeasureTime; + + /** + * @param args + * main parameters : args[7] may contain minimum measurement time + * in secondes. Default : 10. + */ + public ImageViewerPerfTest(String args[]) { + this.minMeasureTime = getMinMeasurementTime(args); + } + + /** + * + * @param args + * main parameters : args[7] may contain minimum measurement time + * in secondes. Default : 10. + * @return extension to use for encoding + */ + protected int getMinMeasurementTime(String args[]) { + int time; + if (args != null && args.length > 7) { + time = Integer.parseInt(args[7]); + } else { + time = DEFAULT_MIN_MEASURE_TIME; + } + return time; + } + + /** + * Process inFile image, update processedFiles list and failures map, and + * append measurements to results_perfs.txt. All parameters must not be + * null. + * + * @param ext + * output encoding image format + * @param outDir + * output directory + * @param post + * post parameters + * @param failures + * map failed file urls to eventual exception + * @param inFile + * file image to process + * @throws IOException + * when an read/write error occured + */ + @Override + protected void processFile(String ext, File outDir, serverObjects post, Map<String, Throwable> failures, + File inFile) throws IOException { + /* Delete eventual previous result file */ + System.out + .println("Measuring render with file : " + inFile.getAbsolutePath() + " encoded To : " + ext); + File outFile = new File(outDir, inFile.getName() + "." + ext); + if (outFile.exists()) { + outFile.delete(); + } + + String urlString = inFile.getAbsolutePath(); + EncodedImage img = null; + Exception error = null; + long beginTime = System.nanoTime(), time, minTime = Long.MAX_VALUE, maxTime = 0, meanTime = 0, totalTime = 0; + int step = 0; + for (step = 0; (totalTime / 1000000000) < this.minMeasureTime; step++) { + beginTime = System.nanoTime(); + ImageInputStream inStream = ImageIO.createImageInputStream(inFile); + try { + img = this.VIEWER.parseAndScale(post, true, new DigestURL(urlString), ext, inStream); + } catch (Exception e) { + error = e; + } + time = System.nanoTime() - beginTime; + minTime = Math.min(minTime, time); + maxTime = Math.max(maxTime, time); + totalTime += time; + } + if (step > 0) { + meanTime = totalTime / step; + } else { + meanTime = totalTime; + } + PrintWriter resultsWriter = new PrintWriter(new FileWriter(new File(outDir, "results_perfs.txt"), true)); + try { + writeMessage("Measured render with file : " + inFile.getAbsolutePath() + " encoded To : " + ext, + resultsWriter); + if(img == null) { + writeMessage("Image could not be rendered! Measurement show time needed to read and parse image data until error detection.", resultsWriter); + } + writeMessage("Render total time (ms) : " + (totalTime) / 1000000 + " on " + step + " steps.", + resultsWriter); + writeMessage("Render mean time (ms) : " + (meanTime) / 1000000, resultsWriter); + writeMessage("Render min time (ms) : " + (minTime) / 1000000, resultsWriter); + writeMessage("Render max time (ms) : " + (maxTime) / 1000000, resultsWriter); + } finally { + resultsWriter.close(); + } + + if (img == null) { + failures.put(urlString, error); + } else { + FileOutputStream outFileStream = null; + try { + outFileStream = new FileOutputStream(outFile); + img.getImage().writeTo(outFileStream); + } finally { + if (outFileStream != null) { + outFileStream.close(); + } + img.getImage().close(); + } + } + } + + /** + * Test image(s) (default : classpath resource folder /viewImageTest/test/) + * are parsed and rendered again and again until specified time (default : + * 10 seconds) elapsed. Then rendered image is written to outDir for visual + * check and measured statistics are displayed. + * + * @param args + * may be empty or contain parameters to override defaults : + * <ul> + * <li>args[0] : input image file URL or folder containing image + * files URL. Default : classpath resource /viewImageTest/test/ + * </li> + * <li>args[1] : output format name (for example : "jpg") for + * rendered image. Defaut : "png".</li> + * <li>args[2] : ouput folder URL. Default : + * "[system tmp dir]/Test".</li> + * <li>args[3] : max width (in pixels) for rendered image. May be + * set to zero to specify no max width. Default : no value.</li> + * <li>args[4] : max height (in pixels) for rendered image. May + * be set to zero to specify no max height. Default : no value. + * </li> + * <li>args[5] : set to "quadratic" to render square output + * image. May be set to any string to specify no quadratic shape. + * Default : false.</li> + * <li>args[6] : set to "recursive" to process recursively sub + * folders. Default : false.</li> + * <li>args[7] : minimum measurement time in secondes. Default : + * 10.</li> + * </ul> + * @throws IOException + * when a read/write error occured + */ + public static void main(String args[]) throws IOException { + ImageViewerPerfTest test = new ImageViewerPerfTest(args); + File inFile = test.getInputURL(args); + String ext = test.getEncodingExt(args); + File outDir = test.getOuputDir(args); + boolean recursive = test.isRecursive(args); + serverObjects post = test.makePostParams(args); + outDir.mkdirs(); + + File[] inFiles; + if (inFile.isFile()) { + inFiles = new File[1]; + inFiles[0] = inFile; + System.out.println( + "Measuring render with file : " + inFile.getAbsolutePath() + " encoded To : " + ext); + } else if (inFile.isDirectory()) { + inFiles = inFile.listFiles(); + System.out.println("Measuring render with files in folder : " + inFile.getAbsolutePath() + + " encoded To : " + ext); + } else { + inFiles = new File[0]; + } + if (inFiles.length == 0) { + throw new IllegalArgumentException(inFile.getAbsolutePath() + " is not a valid file or folder url."); + } + + System.out.println("Rendered images will be written in dir : " + outDir.getAbsolutePath()); + + List<File> processedFiles = new ArrayList<File>(); + Map<String, Throwable> failures = new TreeMap<>(); + try { + long time = System.nanoTime(); + test.processFiles(ext, recursive, outDir, post, inFiles, processedFiles, failures); + time = System.nanoTime() - time; + test.displayResults(processedFiles, failures, time, outDir); + } finally { + ConcurrentLog.shutdown(); + } + + } + +} |