private void accept(WebDriver driver, String message) {
StopWatch stopWatch = new Log4JStopWatch();
stopWatch.start();
WebElement img = driver.findElement(By.xpath("//img[@alt='Click to sign']"));
driver.manage().timeouts().implicitlyWait(waitTimeout, TimeUnit.SECONDS);
img.click();
List<WebElement> signed_imgs = driver.findElements(By.xpath("//img[@alt='Signed']"));
driver.manage().timeouts().implicitlyWait(waitTimeout, TimeUnit.SECONDS);
if (signed_imgs.size() != 0) {
stopWatch.stop("accept", message);
} else {
randomDelay();
stopWatch.start();
WebElement awsForm = driver.findElement(By.name("awsForm"));
driver.manage().timeouts().implicitlyWait(waitTimeout, TimeUnit.SECONDS);
awsForm.submit();
signed_imgs = driver.findElements(By.xpath("//img[@alt='Signed']"));
driver.manage().timeouts().implicitlyWait(waitTimeout, TimeUnit.SECONDS);
stopWatch.stop("accept'", message);
}
}
public void testOverflowHandling() throws Exception {
Logger logger = Logger.getLogger("AppenderTest.overflowTest");
AsyncCoalescingStatisticsAppender appender = new AsyncCoalescingStatisticsAppender();
appender.setName("overflowTestAppender");
appender.setTimeSlice(1000);
appender.setQueueSize(2); // set low queue size so we overflow
logger.addAppender(appender);
logger.setAdditivity(false);
logger.setLevel(Level.INFO);
appender.activateOptions();
for (int i = 0; i < 1000; i++) {
StopWatch stopWatch = new StopWatch("testOverflow");
Math
.random(); // this should happen super fast, faster than the appender's Dispatcher thread
// can drain
logger.info(stopWatch.stop());
}
// again close the appender
appender.close();
assertTrue(
"Expected some stop watch messages to get discarded",
appender.getNumDiscardedMessages() > 0);
}
// test for http://jira.codehaus.org/browse/PERFFORJ-22
public void testFlushOnShutdown() throws Exception {
DOMConfigurator.configure(getClass().getResource("log4j-shutdownbug.xml"));
// make a bunch of logs, but not enough to go over the timeslice.
for (int i = 0; i < 5; i++) {
StopWatch stopWatch = new Log4JStopWatch("tag1");
Thread.sleep(10 * i);
stopWatch.stop();
}
// at this point none of the file appenders will have written anything because they haven't been
// flushed
assertEquals("", FileUtils.readFileToString(new File("target/stats-shutdownbug.log")));
assertEquals("", FileUtils.readFileToString(new File("target/graphs-shutdownbug.log")));
// now, to simulate shutdown, get the async appender and run the shutdown hook. We need to use
// reflection
// because the shutdown hook is private.
AsyncCoalescingStatisticsAppender appender =
(AsyncCoalescingStatisticsAppender)
Logger.getLogger(StopWatch.DEFAULT_LOGGER_NAME).getAppender("coalescingStatistics");
Field shutdownField = appender.getClass().getDeclaredField("shutdownHook");
shutdownField.setAccessible(true);
Thread shutdownHook = (Thread) shutdownField.get(appender);
shutdownHook.run();
// now there should be data in the files
assertFalse("".equals(FileUtils.readFileToString(new File("target/stats-shutdownbug.log"))));
assertFalse("".equals(FileUtils.readFileToString(new File("target/graphs-shutdownbug.log"))));
}
/**
* Will only ever be accessed by a single thread. Rechecks the target update time again in case a
* second write thread was blocking the current one. {@link #lastUpdateRun} gets set to a negative
* value to specify that this method is currently running.
*/
public void doUpdate() {
// Check whether entry is required.
if (!state.get().checkNeedsUpdate(forceUpdateInterval)) {
return;
}
// Prevent recursion!
// ------------------
// To prevent another call from entering this block it's
// necessary to set active
if (!active.compareAndSet(false, true)) {
return;
}
try {
final Set<String> ids = sessions.keySet();
log.info("Synchronizing session cache. Count = " + ids.size());
final StopWatch sw = new Slf4JStopWatch();
for (String id : ids) {
reload(id);
}
sw.stop("omero.sessions.synchronization");
log.info(String.format("Synchronization took %s ms.", sw.getElapsedTime()));
} catch (Exception e) {
log.error("Error synchronizing cache", e);
} finally {
active.set(false);
}
}
public void handleComponentEvent(
ComponentEventRequestParameters parameters, ComponentRequestHandler handler)
throws IOException {
StopWatch watch = profilePage(parameters.getActivePageName());
handler.handleComponentEvent(parameters);
watch.stop(watch.getTag(), "Component event handled");
}
public void testAwsppHtmlUtil(int docs, int times) throws InterruptedException {
init();
String message = Thread.currentThread().getName() + " loop:(%d/%d), docs(%d/%d) ";
String message1 = Thread.currentThread().getName() + " loop:(%d/%d)";
HtmlUnitDriver driver = new HtmlUnitDriver(true);
for (int j = 0; j < times; j++) {
StopWatch stopWatch = new Log4JStopWatch();
stopWatch.start();
goToTestPage(driver);
stopWatch.stop("TestPage", String.format(message1, j, times));
randomDelay();
stopWatch.start();
createTransaction(driver);
stopWatch.stop("Create/Resume", String.format(message, j, times, i, docs));
for (int i = 0; i < docs; i++) {
accept(driver, String.format(message, j, times, i, docs));
randomDelay();
stopWatch.start();
submit(driver);
if (i == docs - 1) {
WebElement link = driver.findElement(By.linkText("Go Back to Parent Page"));
driver.manage().timeouts().implicitlyWait(waitTimeout, TimeUnit.SECONDS);
} else {
WebElement img = driver.findElement(By.xpath("//img[@alt='Click to sign']"));
driver.manage().timeouts().implicitlyWait(waitTimeout, TimeUnit.SECONDS);
}
stopWatch.stop("Submit", message);
}
WebElement link = driver.findElement(By.linkText("Go Back to Parent Page"));
driver.manage().timeouts().implicitlyWait(waitTimeout, TimeUnit.SECONDS);
stopWatch.stop("Submit-f", String.format(message, j, times, i, docs));
link.click();
}
driver.close();
}
@Override
public void postHandle(
HttpServletRequest request,
HttpServletResponse response,
Object handler,
ModelAndView modelAndView)
throws Exception {
StopWatch stopWatch = (StopWatch) request.getAttribute(ATTRIBUTE);
if (stopWatch != null) {
stopWatch.stop();
}
}
/**
* matrix test
*
* @throws Exception exception
*/
public void testMatrix() throws Exception {
ChatMessage msg = constructMessage();
int count = 100000;
// hot swap
for (int i = 0; i < 10000; i++) {
hessian(msg);
jackson(msg);
jackson2(msg);
msgpack(msg);
}
System.out.println(count + " loop:");
StopWatch stopWatch = new StopWatch();
stopWatch.start("hessian");
for (int i = 0; i < count; i++) {
hessian(msg);
}
stopWatch.stop("hessian");
System.out.println(stopWatch.getTag() + ":" + stopWatch.getElapsedTime());
stopWatch.start("jackson");
for (int i = 0; i < count; i++) {
jackson(msg);
}
stopWatch.stop("jackson");
System.out.println(stopWatch.getTag() + ":" + stopWatch.getElapsedTime());
stopWatch.start("msgpack");
for (int i = 0; i < count; i++) {
msgpack(msg);
}
stopWatch.stop("msgpack");
System.out.println(stopWatch.getTag() + ":" + stopWatch.getElapsedTime());
stopWatch.start("jackson2");
for (int i = 0; i < count; i++) {
jackson2(msg);
}
stopWatch.stop("jackson2");
System.out.println(stopWatch.getTag() + ":" + stopWatch.getElapsedTime());
}
public void testCsvRenderer() throws Exception {
DOMConfigurator.configure(getClass().getResource("log4jWCsv.xml"));
Logger logger = Logger.getLogger("org.perf4j.CsvAppenderTest");
for (int i = 0; i < 20; i++) {
StopWatch stopWatch = new Log4JStopWatch(logger);
Thread.sleep(i * 10);
stopWatch.stop("csvTest");
}
// close the appender
logger.getAppender("coalescingStatistics").close();
// verify the statisticsLog.csv file
DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
for (Object line : FileUtils.readLines(new File("./target/statisticsLog.csv"))) {
String[] values = line.toString().split(",");
// first column is the tag
assertEquals("\"csvTest\"", values[0]);
// next 2 columns are the dates - ensure they can be parsed
assertTrue(dateFormat.parse(values[1]).before(dateFormat.parse(values[2])));
// next 3 columns are mean, min and max
double mean = Double.parseDouble(values[3]);
int min = Integer.parseInt(values[4]);
int max = Integer.parseInt(values[5]);
assertTrue(mean >= min && mean <= max);
// next column is stddev - ust make sure it's parseable
Double.parseDouble(values[6]);
// next column is count
assertTrue(Integer.parseInt(values[7]) < 20);
// final column is TPS - just make sure it's parseable
Double.parseDouble(values[8]);
}
// verify the pivotedStatisticsLog.csv file
for (Object line : FileUtils.readLines(new File("./target/pivotedStatisticsLog.csv"))) {
String[] values = line.toString().split(",");
// first 2 columns are the dates - ensure they can be parsed
assertTrue(dateFormat.parse(values[0]).before(dateFormat.parse(values[1])));
// next column is mean, ensure it can be parsed
Double.parseDouble(values[2]);
// last column should be empty, so make sure last char on string is comma
assertEquals(',', line.toString().charAt(line.toString().length() - 1));
}
}
public static void main(String[] args) throws LPException {
final int rows = 40;
final int cols = rows;
logger.trace("Start Unwrapping");
logger.info("Simulate Data");
SimulateData simulateData = new SimulateData(rows, cols);
simulateData.peaks();
DoubleMatrix Phi = simulateData.getSimulatedData();
DoubleMatrix Psi = UnwrapUtils.wrapDoubleMatrix(Phi);
StopWatch clockFull = new StopWatch();
clockFull.start();
Unwrapper unwrapper = new Unwrapper(Psi);
unwrapper.unwrap();
clockFull.stop();
logger.info("Total processing time {} [sec]", (double) (clockFull.getElapsedTime()) / 1000);
}
public void run() {
String loggingTag = "tag" + index.getAndIncrement();
for (int i = 0; i < STOP_WATCH_COUNT; i++) {
StopWatch stopWatch = new Log4JStopWatch(loggingTag);
int sleepTime = (int) (Math.random() * 400);
try {
Thread.sleep(sleepTime);
} catch (Exception e) {
/*do nothing*/
}
stopWatch.stop();
}
// this last sleep here seems necessary because otherwise Thread.join() above is returning
// before
// we're really done.
try {
Thread.sleep(10);
} catch (Exception e) {
/*ignore*/
}
}
private void costantiniUnwrap() throws LPException {
final int ny = wrappedPhase.rows - 1; // start from Zero!
final int nx = wrappedPhase.columns - 1; // start from Zero!
if (wrappedPhase.isVector()) throw new IllegalArgumentException("Input must be 2D array");
if (wrappedPhase.rows < 2 || wrappedPhase.columns < 2)
throw new IllegalArgumentException("Size of input must be larger than 2");
// Default weight
DoubleMatrix w1 = DoubleMatrix.ones(ny + 1, 1);
w1.put(0, 0.5);
w1.put(w1.length - 1, 0.5);
DoubleMatrix w2 = DoubleMatrix.ones(1, nx + 1);
w2.put(0, 0.5);
w2.put(w2.length - 1, 0.5);
DoubleMatrix weight = w1.mmul(w2);
DoubleMatrix i, j, I_J, IP1_J, I_JP1;
DoubleMatrix Psi1, Psi2;
DoubleMatrix[] ROWS;
// Compute partial derivative Psi1, eqt (1,3)
i = intRangeDoubleMatrix(0, ny - 1);
j = intRangeDoubleMatrix(0, nx);
ROWS = grid2D(i, j);
I_J = JblasUtils.sub2ind(wrappedPhase.rows, ROWS[0], ROWS[1]);
IP1_J = JblasUtils.sub2ind(wrappedPhase.rows, ROWS[0].add(1), ROWS[1]);
Psi1 =
JblasUtils.getMatrixFromIdx(wrappedPhase, IP1_J)
.sub(JblasUtils.getMatrixFromIdx(wrappedPhase, I_J));
Psi1 = UnwrapUtils.wrapDoubleMatrix(Psi1);
// Compute partial derivative Psi2, eqt (2,4)
i = intRangeDoubleMatrix(0, ny);
j = intRangeDoubleMatrix(0, nx - 1);
ROWS = grid2D(i, j);
I_J = JblasUtils.sub2ind(wrappedPhase.rows, ROWS[0], ROWS[1]);
I_JP1 = JblasUtils.sub2ind(wrappedPhase.rows, ROWS[0], ROWS[1].add(1));
Psi2 =
JblasUtils.getMatrixFromIdx(wrappedPhase, I_JP1)
.sub(JblasUtils.getMatrixFromIdx(wrappedPhase, I_J));
Psi2 = UnwrapUtils.wrapDoubleMatrix(Psi2);
// Compute beq
DoubleMatrix beq = DoubleMatrix.zeros(ny, nx);
i = intRangeDoubleMatrix(0, ny - 1);
j = intRangeDoubleMatrix(0, nx - 1);
ROWS = grid2D(i, j);
I_J = JblasUtils.sub2ind(Psi1.rows, ROWS[0], ROWS[1]);
I_JP1 = JblasUtils.sub2ind(Psi1.rows, ROWS[0], ROWS[1].add(1));
beq.addi(JblasUtils.getMatrixFromIdx(Psi1, I_JP1).sub(JblasUtils.getMatrixFromIdx(Psi1, I_J)));
I_J = JblasUtils.sub2ind(Psi2.rows, ROWS[0], ROWS[1]);
I_JP1 = JblasUtils.sub2ind(Psi2.rows, ROWS[0].add(1), ROWS[1]);
beq.subi(JblasUtils.getMatrixFromIdx(Psi2, I_JP1).sub(JblasUtils.getMatrixFromIdx(Psi2, I_J)));
beq.muli(-1 / (2 * Constants._PI));
for (int k = 0; k < beq.length; k++) {
beq.put(k, Math.round(beq.get(k)));
}
beq.reshape(beq.length, 1);
logger.debug("Constraint matrix");
i = intRangeDoubleMatrix(0, ny - 1);
j = intRangeDoubleMatrix(0, nx - 1);
ROWS = grid2D(i, j);
DoubleMatrix ROW_I_J = JblasUtils.sub2ind(i.length, ROWS[0], ROWS[1]);
int nS0 = nx * ny;
// Use by S1p, S1m
DoubleMatrix[] COLS;
COLS = grid2D(i, j);
DoubleMatrix COL_IJ_1 = JblasUtils.sub2ind(i.length, COLS[0], COLS[1]);
COLS = grid2D(i, j.add(1));
DoubleMatrix COL_I_JP1 = JblasUtils.sub2ind(i.length, COLS[0], COLS[1]);
int nS1 = (nx + 1) * (ny);
// SOAPBinding.Use by S2p, S2m
COLS = grid2D(i, j);
DoubleMatrix COL_IJ_2 = JblasUtils.sub2ind(i.length + 1, COLS[0], COLS[1]);
COLS = grid2D(i.add(1), j);
DoubleMatrix COL_IP1_J = JblasUtils.sub2ind(i.length + 1, COLS[0], COLS[1]);
int nS2 = nx * (ny + 1);
// Equality constraint matrix (Aeq)
/*
S1p = + sparse(ROW_I_J, COL_I_JP1,1,nS0,nS1) ...
- sparse(ROW_I_J, COL_IJ_1,1,nS0,nS1);
S1m = -S1p;
S2p = - sparse(ROW_I_J, COL_IP1_J,1,nS0,nS2) ...
+ sparse(ROW_I_J, COL_IJ_2,1,nS0,nS2);
S2m = -S2p;
*/
// ToDo: Aeq matrix should be sparse from it's initialization, look into JblasMatrix factory for
// howto
// ...otherwise even a data set of eg 40x40 pixels will exhaust heap:
// ... dimension of Aeq (equality constraints) matrix for 30x30 input is 1521x6240 matrix
// ... dimension of Aeq ( ) matrix for 50x50 input is 2401x9800
// ... dimension of Aeq ( ) matrix for 512x512 input is 261121x1046528
DoubleMatrix S1p =
JblasUtils.setUpMatrixFromIdx(nS0, nS1, ROW_I_J, COL_I_JP1)
.sub(JblasUtils.setUpMatrixFromIdx(nS0, nS1, ROW_I_J, COL_IJ_1));
DoubleMatrix S1m = S1p.neg();
DoubleMatrix S2p =
JblasUtils.setUpMatrixFromIdx(nS0, nS2, ROW_I_J, COL_IP1_J)
.neg()
.add(JblasUtils.setUpMatrixFromIdx(nS0, nS2, ROW_I_J, COL_IJ_2));
DoubleMatrix S2m = S2p.neg();
DoubleMatrix Aeq =
concatHorizontally(concatHorizontally(S1p, S1m), concatHorizontally(S2p, S2m));
final int nObs = Aeq.columns;
final int nUnkn = Aeq.rows;
DoubleMatrix c1 = JblasUtils.getMatrixFromRange(0, ny, 0, weight.columns, weight);
DoubleMatrix c2 = JblasUtils.getMatrixFromRange(0, weight.rows, 0, nx, weight);
c1.reshape(c1.length, 1);
c2.reshape(c2.length, 1);
DoubleMatrix cost =
DoubleMatrix.concatVertically(
DoubleMatrix.concatVertically(c1, c1), DoubleMatrix.concatVertically(c2, c2));
logger.debug("Minimum network flow resolution");
StopWatch clockLP = new StopWatch();
LinearProgram lp = new LinearProgram(cost.data);
lp.setMinProblem(true);
boolean[] integerBool = new boolean[nObs];
double[] lowerBound = new double[nObs];
double[] upperBound = new double[nObs];
for (int k = 0; k < nUnkn; k++) {
lp.addConstraint(new LinearEqualsConstraint(Aeq.getRow(k).toArray(), beq.get(k), "cost"));
}
for (int k = 0; k < nObs; k++) {
integerBool[k] = true;
lowerBound[k] = 0;
upperBound[k] = 99999;
}
// setup bounds and integer nature
lp.setIsinteger(integerBool);
lp.setUpperbound(upperBound);
lp.setLowerbound(lowerBound);
LinearProgramSolver solver = SolverFactory.newDefault();
// double[] solution;
// solution = solver.solve(lp);
DoubleMatrix solution = new DoubleMatrix(solver.solve(lp));
clockLP.stop();
logger.debug("Total GLPK time: {} [sec]", (double) (clockLP.getElapsedTime()) / 1000);
// Displatch the LP solution
int offset;
int[] idx1p = JblasUtils.intRangeIntArray(0, nS1 - 1);
DoubleMatrix x1p = solution.get(idx1p);
x1p.reshape(ny, nx + 1);
offset = idx1p[nS1 - 1] + 1;
int[] idx1m = JblasUtils.intRangeIntArray(offset, offset + nS1 - 1);
DoubleMatrix x1m = solution.get(idx1m);
x1m.reshape(ny, nx + 1);
offset = idx1m[idx1m.length - 1] + 1;
int[] idx2p = JblasUtils.intRangeIntArray(offset, offset + nS2 - 1);
DoubleMatrix x2p = solution.get(idx2p);
x2p.reshape(ny + 1, nx);
offset = idx2p[idx2p.length - 1] + 1;
int[] idx2m = JblasUtils.intRangeIntArray(offset, offset + nS2 - 1);
DoubleMatrix x2m = solution.get(idx2m);
x2m.reshape(ny + 1, nx);
// Compute the derivative jumps, eqt (20,21)
DoubleMatrix k1 = x1p.sub(x1m);
DoubleMatrix k2 = x2p.sub(x2m);
// (?) Round to integer solution
if (roundK == true) {
for (int idx = 0; idx < k1.length; idx++) {
k1.put(idx, FastMath.floor(k1.get(idx)));
}
for (int idx = 0; idx < k2.length; idx++) {
k2.put(idx, FastMath.floor(k2.get(idx)));
}
}
// Sum the jumps with the wrapped partial derivatives, eqt (10,11)
k1.reshape(ny, nx + 1);
k2.reshape(ny + 1, nx);
k1.addi(Psi1.div(Constants._TWO_PI));
k2.addi(Psi2.div(Constants._TWO_PI));
// Integrate the partial derivatives, eqt (6)
// cumsum() method in JblasTester -> see cumsum_demo() in JblasTester.cumsum_demo()
DoubleMatrix k2_temp = DoubleMatrix.concatHorizontally(DoubleMatrix.zeros(1), k2.getRow(0));
k2_temp = JblasUtils.cumsum(k2_temp, 1);
DoubleMatrix k = DoubleMatrix.concatVertically(k2_temp, k1);
k = JblasUtils.cumsum(k, 1);
// Unwrap - final solution
unwrappedPhase = k.mul(Constants._TWO_PI);
}
public void handlePageRender(
PageRenderRequestParameters parameters, ComponentRequestHandler handler) throws IOException {
StopWatch watch = profilePage(parameters.getLogicalPageName());
handler.handlePageRender(parameters);
watch.stop(watch.getTag(), "Page rendered");
}
public void setOverlays_async(
AMD_RenderingEngine_setOverlays __cb,
RLong tableId,
RLong imageId,
Map<Long, Integer> rowColorMap,
Current __current)
throws ServerError {
try {
final IceMapper mapper = new IceMapper(IceMapper.VOID);
// Sanity check so that we do not attempt to slice the entire table
if (rowColorMap.size() == 0) {
callInvokerOnMappedArgs(mapper, __cb, __current, new Object[] {null});
return;
}
// Translate our set of rows to an array for table slicing
Set<Long> rowsAsSet = rowColorMap.keySet();
long[] rows = new long[rowsAsSet.size()];
int rowIndex = 0;
for (Long row : rowsAsSet) {
rows[rowIndex] = row.longValue();
rowIndex++;
}
// Load the table and find the index of the mask column, throwing an
// exception if the mask column does not exist.
StopWatch s1 = new CommonsLogStopWatch("omero.getTable");
TablePrx table = roiService.getTable(tableId.getValue());
s1.stop();
s1 = new CommonsLogStopWatch("omero.getHeaders");
Column[] columns = table.getHeaders();
s1.stop();
int maskColumnIndex = 0;
for (; maskColumnIndex < columns.length; maskColumnIndex++) {
if (columns[maskColumnIndex] instanceof MaskColumn) {
break;
}
}
if (maskColumnIndex == columns.length) {
throw new IllegalArgumentException(
"Unable to find mask column in table: " + tableId.getValue());
}
// Slice the table and feed the byte array encoded bit masks to the
// rendering engine servant.
s1 = new CommonsLogStopWatch("omero.sliceAndBuildREMap");
Data data = table.slice(new long[] {maskColumnIndex}, rows);
MaskColumn maskColumn = (MaskColumn) data.columns[0];
final Map<byte[], Integer> forRenderingEngine = new LinkedHashMap<byte[], Integer>();
for (int i = 0; i < rows.length; i++) {
forRenderingEngine.put(maskColumn.bytes[i], rowColorMap.get(rows[i]));
}
s1.stop();
callInvokerOnMappedArgs(mapper, __cb, __current, forRenderingEngine);
} catch (Throwable t) {
if (!(t instanceof Exception)) {
__cb.ice_exception(new InternalException());
} else {
__cb.ice_exception((Exception) t);
}
}
}