/* | |
* Licensed to the Apache Software Foundation (ASF) under one | |
* or more contributor license agreements. See the NOTICE file | |
* distributed with this work for additional information | |
* regarding copyright ownership. The ASF licenses this file | |
* to you under the Apache License, Version 2.0 (the | |
* "License"); you may not use this file except in compliance | |
* with the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, | |
* software distributed under the License is distributed on an | |
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
* KIND, either express or implied. See the License for the | |
* specific language governing permissions and limitations | |
* under the License. | |
*/ | |
package org.apache.uima.test.junit_extension; | |
import java.io.File; | |
import java.io.FileWriter; | |
import java.util.Calendar; | |
import java.util.GregorianCalendar; | |
import org.apache.uima.internal.util.TimeSpan; | |
/** | |
* PerformanceTestResultImpl implements the PerformanceTestResult interface and provides the results of a performance | |
* test run. | |
* | |
*/ | |
public class PerformanceTestResultImpl implements PerformanceTestResult { | |
private static String NEWLINE = System.getProperty("line.separator"); | |
private boolean repeatSingleMode = false; | |
private boolean doWarmup = false; | |
private int numsToRun = 1; | |
private File aeDescFile = null; | |
private File testFileDir = null; | |
private int numberOfFiles = 0; | |
private long collectionFileSize = 0; | |
private int numberOfCharacters = 0; | |
private String datapath = null; | |
private int numberOfCreatedAnnotations = 0; | |
private TimeSpan initTime = null; | |
private TimeSpan warmupTime = null; | |
private TimeSpan overallTime = null; | |
private TimeSpan ioTime = null; | |
private TimeSpan processingTime = null; | |
private TimeSpan cleanupTime = null; | |
private TimeSpan documentPreparationTime = null; | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getNumberOfProcessedCharacters() | |
*/ | |
public int getNumberOfProcessedCharacters() { | |
return this.numberOfCharacters * this.numsToRun; | |
} | |
/** | |
* @param numberOfCharacters | |
* The number of characters. | |
*/ | |
public void setNumberOfCharacters(int numberOfCharacters) { | |
this.numberOfCharacters = numberOfCharacters; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getNumberOfProcessedFiles() | |
*/ | |
public int getNumberOfProcessedFiles() { | |
return this.numberOfFiles * this.numsToRun; | |
} | |
/** | |
* @param numberOfFiles | |
* The number of files. | |
*/ | |
public void setNumberOfFiles(int numberOfFiles) { | |
this.numberOfFiles = numberOfFiles; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getUIMADatapath() | |
*/ | |
public String getUIMADatapath() { | |
return this.datapath; | |
} | |
/** | |
* @param datapath | |
* The UIMA datapath. | |
*/ | |
public void setDatapath(String datapath) { | |
this.datapath = datapath; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getAeInitTime() | |
*/ | |
public TimeSpan getAeInitTime() { | |
return this.initTime; | |
} | |
/** | |
* @param initTime | |
* The analysis engine init time. | |
*/ | |
public void setInitTime(TimeSpan initTime) { | |
this.initTime = initTime; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getFileIoTime() | |
*/ | |
public TimeSpan getFileIoTime() { | |
return this.ioTime; | |
} | |
/** | |
* @param ioTime | |
* The file io time to set. | |
*/ | |
public void setIoTime(TimeSpan ioTime) { | |
this.ioTime = ioTime; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getNumberOfCreatedAnnotations() | |
*/ | |
public int getNumberOfCreatedAnnotations() { | |
return this.numberOfCreatedAnnotations; | |
} | |
/** | |
* @param numberOfCreatedAnnotations | |
* The number of created annotations to set. | |
*/ | |
public void setNumberOfCreatedAnnotations(int numberOfCreatedAnnotations) { | |
this.numberOfCreatedAnnotations = numberOfCreatedAnnotations; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getNumberOfRepeatedRuns() | |
*/ | |
public int getNumberOfRepeatedRuns() { | |
return this.numsToRun; | |
} | |
/** | |
* @param numsToRun | |
* The number of repeated runs. | |
*/ | |
public void setNumsToRun(int numsToRun) { | |
this.numsToRun = numsToRun; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getOverallTime() | |
*/ | |
public TimeSpan getOverallTime() { | |
return this.overallTime; | |
} | |
/** | |
* @param overallTime | |
* The overall processing time. | |
*/ | |
public void setOverallTime(TimeSpan overallTime) { | |
this.overallTime = overallTime; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getAeProcessingTime() | |
*/ | |
public TimeSpan getAeProcessingTime() { | |
return this.processingTime; | |
} | |
/** | |
* @param processingTime | |
* The analysis engine processing time. | |
*/ | |
public void setProcessingTime(TimeSpan processingTime) { | |
this.processingTime = processingTime; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#isRepeatSingleMode() | |
*/ | |
public boolean isRepeatSingleMode() { | |
return this.repeatSingleMode; | |
} | |
/** | |
* @param repeatSingleMode | |
* The repeat single mode setting | |
*/ | |
public void setRepeatSingleMode(boolean repeatSingleMode) { | |
this.repeatSingleMode = repeatSingleMode; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getAeDescFilePath() | |
*/ | |
public String getAeDescFilePath() { | |
return this.aeDescFile.getAbsolutePath(); | |
} | |
/** | |
* @param aeDescFile | |
* The analysis engine descriptor file. | |
*/ | |
public void setAeDescFilePath(File aeDescFile) { | |
this.aeDescFile = aeDescFile; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getTestFileDirectoryPath() | |
*/ | |
public String getTestFileDirectoryPath() { | |
return this.testFileDir.getAbsolutePath(); | |
} | |
/** | |
* @param testFileDir | |
* The test file directory. | |
*/ | |
public void setTestFileDir(File testFileDir) { | |
this.testFileDir = testFileDir; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getAeWarmupTime() | |
*/ | |
public TimeSpan getAeWarmupTime() { | |
return this.warmupTime; | |
} | |
/** | |
* @param warmupTime | |
* The analysis engine warmup time. | |
*/ | |
public void setWarmupTime(TimeSpan warmupTime) { | |
this.warmupTime = warmupTime; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#isDoAeWarmup() | |
*/ | |
public boolean isDoAeWarmup() { | |
return this.doWarmup; | |
} | |
/** | |
* @param doWarmup | |
* the doWarmup setting | |
*/ | |
public void setDoWarmup(boolean doWarmup) { | |
this.doWarmup = doWarmup; | |
} | |
/** | |
* returns a performance report with the current performance results. | |
* | |
* @see java.lang.Object#toString() | |
*/ | |
public String toString() { | |
StringBuffer resultString = new StringBuffer(); | |
resultString.append(NEWLINE + "Performance Test run results " + NEWLINE); | |
resultString.append("-----------------------------" + NEWLINE + NEWLINE); | |
resultString.append("ConfigParameters: " + NEWLINE); | |
resultString.append("repeat-single mode is: " + this.repeatSingleMode + NEWLINE); | |
resultString.append("doWarump is: " + this.doWarmup + NEWLINE); | |
resultString.append("Run test " + this.numsToRun + " times" + NEWLINE); | |
resultString.append("Use " + this.aeDescFile.getAbsolutePath() + " descriptor" + NEWLINE); | |
resultString.append("Fileset " + this.testFileDir + " is used" + NEWLINE); | |
resultString.append("Datapath setting is: " + this.datapath + NEWLINE); | |
resultString.append("Number of documents (overall): " + this.getNumberOfProcessedFiles() + NEWLINE); | |
resultString | |
.append("Number of characters (overall): " + this.getNumberOfProcessedCharacters() + NEWLINE); | |
resultString.append("Total document size (overall): " | |
+ (float) (this.getProcessedFileSize() / 1024) + " KB" + NEWLINE); | |
resultString.append(NEWLINE + "Initialize: " + NEWLINE); | |
resultString.append("AE initialize time: " + this.initTime + NEWLINE); | |
if (this.doWarmup) { | |
resultString.append("AE warmup time: " + this.warmupTime + NEWLINE); | |
} | |
resultString.append("IO time for reading files: " + this.ioTime + NEWLINE); | |
resultString.append(NEWLINE + "Processing: " + NEWLINE); | |
resultString.append("Created annotations: " + this.numberOfCreatedAnnotations + NEWLINE); | |
resultString.append("Document preparation time: " + this.documentPreparationTime + NEWLINE); | |
resultString.append("Analysis Engine processing time: " + this.processingTime + NEWLINE); | |
if (this.processingTime.getFullMilliseconds() > 0 && this.getProcessedFileSize() > 0) { | |
resultString.append("Processing throughput: " | |
+ (long) ((this.getProcessedFileSize() / 1024) / ((float) this.processingTime | |
.getFullMilliseconds() / 1000)) + " KB/s" + NEWLINE); | |
long mbPerSecond = (long) ((this.getProcessedFileSize() / 1024 / 1024) / ((float) this.processingTime | |
.getFullMilliseconds() / 1000 / 60 / 60)); | |
resultString.append("Processing throughput: " + mbPerSecond + " MB/h" + NEWLINE); | |
} | |
resultString.append(NEWLINE + "Cleanup: " + NEWLINE); | |
resultString.append("Cleanup time: " + this.cleanupTime + NEWLINE); | |
resultString.append(NEWLINE + "Overall: " + NEWLINE); | |
resultString.append("Overall time: " + this.overallTime + NEWLINE); | |
return resultString.toString(); | |
} | |
/** | |
* write performance results as colum. | |
* | |
* @param level | |
* Test level name of the performance test | |
* @param file | |
* Output file where the results are written to | |
* | |
* @throws Exception | |
*/ | |
public void writePerfResultsAsColumn(String level, File file) throws Exception { | |
// set level name to "none" if it is not available | |
if (level == null) { | |
level = "none"; | |
} | |
// create current time stamp | |
GregorianCalendar cal = new GregorianCalendar(); | |
StringBuffer timestamp = new StringBuffer(); | |
timestamp.append(cal.get(Calendar.DATE)); | |
timestamp.append("."); | |
timestamp.append(cal.get(Calendar.MONTH) + 1); | |
timestamp.append("."); | |
timestamp.append(cal.get(Calendar.YEAR)); | |
timestamp.append(" "); | |
timestamp.append(cal.get(Calendar.HOUR_OF_DAY)); | |
timestamp.append(":"); | |
timestamp.append(cal.get(Calendar.MINUTE)); | |
timestamp.append(":"); | |
timestamp.append(cal.get(Calendar.SECOND)); | |
// create result line | |
StringBuffer resultLine = new StringBuffer(); | |
resultLine.append(timestamp.toString()); // add timestamp | |
resultLine.append(" ; "); | |
resultLine.append(level); // add level name | |
resultLine.append(" ; "); | |
resultLine.append(this.repeatSingleMode); // repeate single mode | |
resultLine.append(" ; "); | |
resultLine.append(this.doWarmup); // doWarmup | |
resultLine.append(" ; "); | |
resultLine.append(this.numberOfFiles * this.numsToRun); // number of docs overall | |
resultLine.append(" ; "); | |
resultLine.append(this.numberOfCreatedAnnotations); // number of created annots | |
resultLine.append(" ; "); | |
resultLine.append(this.processingTime); // processing time | |
resultLine.append(" ; "); | |
resultLine.append(this.initTime); // init time | |
resultLine.append(" ; "); | |
resultLine.append(this.ioTime); // io time | |
resultLine.append(System.getProperty("line.separator")); | |
boolean writeHeader = false; | |
// check if file does not exist, write file header | |
if (!file.exists()) { | |
writeHeader = true; | |
} | |
// create outputStream in appending mode | |
FileWriter fileWriter = new FileWriter(file, true); | |
if (writeHeader) { | |
fileWriter | |
.write("Timestamp ; Levelname ; singleMode ; warmup; Docs ; Annotations ; Processing time ; init time ; io time"); | |
fileWriter.write(System.getProperty("line.separator")); | |
} | |
// write result | |
fileWriter.write(resultLine.toString()); | |
// flush and close writer | |
fileWriter.flush(); | |
fileWriter.close(); | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getAeCleanupTime() | |
*/ | |
public TimeSpan getAeCleanupTime() { | |
return this.cleanupTime; | |
} | |
/** | |
* @param cleanupTime | |
* the analysis engine cleanup time | |
*/ | |
public void setCleanupTime(TimeSpan cleanupTime) { | |
this.cleanupTime = cleanupTime; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getDocumentPreparationTime() | |
*/ | |
public TimeSpan getDocumentPreparationTime() { | |
return this.documentPreparationTime; | |
} | |
/** | |
* @param documentPreparationTime | |
* the document preparation time | |
*/ | |
public void setDocumentPreparationTime(TimeSpan documentPreparationTime) { | |
this.documentPreparationTime = documentPreparationTime; | |
} | |
/* (non-Javadoc) | |
* @see org.apache.uima.test.junit_extension.PerformanceTestResult#getProcessedFileSize() | |
*/ | |
public long getProcessedFileSize() { | |
return this.collectionFileSize * this.numsToRun; | |
} | |
/** | |
* @param collectionFileSize | |
* the collection file size | |
*/ | |
public void setTotalFileSize(long collectionFileSize) { | |
this.collectionFileSize = collectionFileSize; | |
} | |
} |