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);
    }
  }
Example #2
0
  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);
  }
Example #3
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());
 }
Example #9
0
  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));
    }
  }
Example #10
0
  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);
  }
Example #11
0
    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*/
      }
    }
Example #12
0
  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);
      }
    }
  }