Ejemplo n.º 1
0
  public static void testBeginEndEmpty(int numtx) throws IOException, CommitUnsuccessfulException {

    PrintWriter out = new PrintWriter(new File("TEmptyTest.txt"));
    out.println("\nTransactionEmptyTest ENTRY");

    double begin_latency = 0;
    double end_latency = 0;
    double abort_latency = 0;
    int newValue = 0;

    for (newValue = 0; newValue < numtx; newValue++) {
      // Begin
      long ts1 = System.nanoTime();
      TransactionState transactionState = transactionManager.beginTransaction();
      long ts2 = System.nanoTime();
      long latency = ts2 - ts1;
      double latency2 = (double) latency / 1000000000;

      begin_latency = begin_latency + latency2;

      // End
      ts1 = System.nanoTime();
      transactionManager.tryCommit(transactionState);
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000;

      end_latency = end_latency + latency2;

      transactionState = transactionManager.beginTransaction();

      // Abort
      ts1 = System.nanoTime();
      transactionManager.abort(transactionState);
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000;

      abort_latency = abort_latency + latency2;
    }

    out.println("\nAverage Begin latency : " + (double) (begin_latency / newValue));
    out.println("Average End latency  : " + (double) (end_latency / newValue));
    out.println("Average Abort latency  : " + (double) (abort_latency / newValue));
    out.println("newValue  : " + newValue);
    out.println("\ntestGetAfterPut EXIT");
    out.close();
  }
Ejemplo n.º 2
0
  public static void testGetAfterPut3(int numtx) throws IOException, CommitUnsuccessfulException {

    int newValue = 0;
    for (newValue = 0; newValue < numtx; newValue++) {
      // Begin
      TransactionState transactionState = transactionManager.beginTransaction(100);

      // Put
      Put lv_put = new Put(Bytes.toBytes("Alto"));
      lv_put.add(FAMILY, QUAL_A, Bytes.toBytes("Palo"));
      lv_put.add(FAMILY, QUAL_B, Bytes.toBytes("Alto"));
      table.put(transactionState, lv_put);

      // Get
      Result row1_A =
          table.get(transactionState, new Get(Bytes.toBytes("Alto")).addColumn(FAMILY, QUAL_A));
      System.out.println(
          "Transactional Get result before put is committed:" + row1_A.size() + ":" + row1_A);

      // Get
      Result row1_B = table.get(new Get(Bytes.toBytes("Alto")).addColumn(FAMILY, QUAL_A));
      System.out.println(
          "Normal Get result before put is committed:" + row1_B.size() + ":" + row1_B);

      // End
      transactionManager.tryCommit(transactionState);

      // Begin
      transactionState = transactionManager.beginTransaction(101);
      // Get
      Result row1_C = table.get(new Get(Bytes.toBytes("Alto")).addColumn(FAMILY, QUAL_A));
      System.out.println("Get after put was commited. Result: " + row1_C);

      // Get
      row1_A =
          table.get(transactionState, new Get(Bytes.toBytes("Alto")).addColumn(FAMILY, QUAL_A));
      System.out.println("Transactional Get after put was commited. Result : " + row1_A);

      // End
      transactionManager.tryCommit(transactionState);
      try {
        transactionState.completeRequest();
      } catch (Exception e) {
        System.out.println("\nCAUGHT\n");
      }
    }
  }
Ejemplo n.º 3
0
  public static void testBegPutEnd(int numtx) throws IOException, CommitUnsuccessfulException {
    PrintWriter beg = new PrintWriter(new File("testBegPutEnd_HbaseTrxBeg.csv"));
    PrintWriter put = new PrintWriter(new File("testBegPutEnd_HbaseTrxPut.csv"));
    PrintWriter end = new PrintWriter(new File("testBegPutEnd_HbaseTrxEnd.csv"));

    TransactionState[] tState = new TransactionState[numtx];
    TransactionState transactionState;
    int newValue;

    for (int i = 0; i < 10; i++) {

      long ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        transactionState = transactionManager.beginTransaction();
        tState[newValue] = transactionState;
      }
      long ts2 = System.nanoTime();
      long latency = ts2 - ts1;
      double latency2 = (double) latency / 1000000;
      beg.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        table.put(
            tState[newValue],
            new Put(ROW1).add(FAMILY, Bytes.toBytes(newValue), Bytes.toBytes(newValue)));
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000;
      put.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        transactionManager.tryCommit(tState[newValue]);
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000;
      end.println(latency2 + ",");
    }
    beg.close();
    put.close();
    end.close();
  }
Ejemplo n.º 4
0
  public static void testBegPutDel(int numtx) throws IOException, CommitUnsuccessfulException {
    PrintWriter bpe = new PrintWriter(new File("HbaseTrxBegPutEnd.csv"));

    int newValue;

    for (int i = 0; i < 10; i++) {
      long ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        TransactionState transactionState = transactionManager.beginTransaction();
        table.put(
            transactionState,
            new Put(ROW2).add(FAMILY, Bytes.toBytes(newValue), Bytes.toBytes(newValue)));
        transactionManager.tryCommit(transactionState);
      }
      long ts2 = System.nanoTime();
      long latency = ts2 - ts1;
      double latency2 = (double) latency / 1000000;
      bpe.println(latency2 + ",");
    }
    bpe.close();
  }
Ejemplo n.º 5
0
  public static void testGetAfterPut2(int numtx) throws IOException, CommitUnsuccessfulException {

    PrintWriter out = new PrintWriter(new File("TWorkTest.txt"));

    out.println("\nTransactionWithWorkTest ENTRY");

    double begin_latency = 0;
    double end_latency = 0;
    double put_latency = 0;
    double get_latency = 0;
    double delete_latency = 0;
    double abort_latency = 0;
    int newValue = 0;

    double hput_latency = 0;
    double hget_latency = 0;
    double hdelete_latency = 0;

    for (newValue = 0; newValue < numtx; newValue++) {
      // Begin
      long ts1 = System.nanoTime();
      TransactionState transactionState = transactionManager.beginTransaction();
      long ts2 = System.nanoTime();
      long latency = ts2 - ts1;
      double latency2 = (double) latency / 1000000000;

      begin_latency = begin_latency + latency2;

      // Put
      ts1 = System.nanoTime();
      table.put(transactionState, new Put(ROW1).add(FAMILY, QUAL_A, Bytes.toBytes(newValue)));
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000;

      put_latency = put_latency + latency2;

      // Abort
      System.nanoTime();
      transactionManager.abort(transactionState);
      try {
        transactionState.completeRequest();
      } catch (Exception e) {
        System.out.println("\nCAUGHT\n");
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000;

      abort_latency = abort_latency + latency2;

      transactionState = transactionManager.beginTransaction();
      table.put(transactionState, new Put(ROW1).add(FAMILY, QUAL_A, Bytes.toBytes(newValue)));

      // End
      ts1 = System.nanoTime();
      transactionManager.tryCommit(transactionState);
      try {
        transactionState.completeRequest();
      } catch (Exception e) {
        System.out.println("\nCAUGHT\n");
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000;

      end_latency = end_latency + latency2;

      transactionState = transactionManager.beginTransaction();
      table.put(transactionState, new Put(ROW1).add(FAMILY, QUAL_A, Bytes.toBytes(newValue)));

      // Get
      ts1 = System.nanoTime();
      Result row1_A = table.get(new Get(ROW1).addColumn(FAMILY, QUAL_A));
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000;

      get_latency = get_latency + latency2;

      transactionManager.tryCommit(transactionState);
      try {
        transactionState.completeRequest();
      } catch (Exception e) {
        System.out.println("\nCAUGHT\n");
      }

      int expected = Bytes.toInt(row1_A.getValue(FAMILY, QUAL_A));
      if (newValue != expected)
        System.out.println(
            "\ntestGetAfterPut : Assert 1 FAILED : expected "
                + expected
                + "newValue "
                + newValue
                + "\n");

      transactionState = transactionManager.beginTransaction();
      table.put(transactionState, new Put(ROW1).add(FAMILY, QUAL_A, Bytes.toBytes(newValue)));

      // Delete
      ts1 = System.nanoTime();
      table.delete(transactionState, new Delete(ROW1).deleteColumns(FAMILY, QUAL_A));
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000;

      delete_latency = delete_latency + latency2;

      transactionManager.tryCommit(transactionState);
      try {
        transactionState.completeRequest();
      } catch (Exception e) {
        System.out.println("\nCAUGHT\n");
      }
    }

    out.println("\nAverage Begin latency : " + (double) (begin_latency / newValue));
    out.println("Average End latency  : " + (double) (end_latency / newValue));
    out.println("Average Abort latency : " + (double) (abort_latency / newValue));
    out.println("Average Put latency  : " + (double) (put_latency / newValue));
    out.println("Average Get latency  : " + (double) (get_latency / newValue));
    out.println("Average Delete latency : " + (double) (delete_latency / newValue));
    out.println("Average HPut latency  : " + (double) (hput_latency / newValue));
    out.println("Average HGet latency  : " + (double) (hget_latency / newValue));
    out.println("\ntestGetAfterPut EXIT");
    out.close();
  }
Ejemplo n.º 6
0
  public static void testGetPutDel(int numtx) throws IOException, CommitUnsuccessfulException {
    PrintWriter get = new PrintWriter(new File("HbaseTrxGet.csv"));
    PrintWriter put = new PrintWriter(new File("HbaseTrxPut.csv"));
    PrintWriter del = new PrintWriter(new File("HbaseTrxDel.csv"));
    PrintWriter beg = new PrintWriter(new File("HbaseTrxBeg.csv"));
    PrintWriter begend = new PrintWriter(new File("HbaseTrxBegEnd.csv"));
    PrintWriter bpe = new PrintWriter(new File("HbaseTrxBegPutEnd.csv"));

    double put_latency = 0;
    double get_latency = 0;
    double delete_latency = 0;
    int newValue;

    for (int i = 0; i < 10; i++) {
      long ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        TransactionState transactionState = transactionManager.beginTransaction();
        table.put(
            transactionState,
            new Put(ROW1).add(FAMILY, Bytes.toBytes(newValue), Bytes.toBytes(newValue)));
        transactionManager.tryCommit(transactionState);
      }
      long ts2 = System.nanoTime();
      long latency = ts2 - ts1;
      double latency2 = (double) latency / 1000000;
      bpe.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        TransactionState transactionState = transactionManager.beginTransaction();
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000;
      beg.println(latency2 + ",");

      TransactionState transactionState = transactionManager.beginTransaction();

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        table.put(
            transactionState,
            new Put(ROW1).add(FAMILY, Bytes.toBytes(newValue), Bytes.toBytes(newValue)));
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000;
      put.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        Result row1_A = table.get(new Get(ROW1).addColumn(FAMILY, Bytes.toBytes(newValue)));
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000;
      get.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        table.delete(
            transactionState, new Delete(ROW1).deleteColumns(FAMILY, Bytes.toBytes(newValue)));
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000;
      del.println(latency2 + ",");
      transactionManager.tryCommit(transactionState);

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        transactionState = transactionManager.beginTransaction();
        transactionManager.tryCommit(transactionState);
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000;
      begend.println(latency2 + ",");
    }
    put.close();
    del.close();
    get.close();
    beg.close();
    bpe.close();
    begend.close();
  }
Ejemplo n.º 7
0
  public static void testBegPutEndSplit(int numtx) throws IOException, CommitUnsuccessfulException {

    PrintWriter beg = new PrintWriter(new File("testBegPutEndSplit_HbaseTrxBeg.csv"));
    PrintWriter put = new PrintWriter(new File("testBegPutEndSplit_HbaseTrxPut.csv"));
    PrintWriter pcom = new PrintWriter(new File("testBegPutEndSplit_HbaseTrxPCommit.csv"));
    PrintWriter dcom = new PrintWriter(new File("testBegPutEndSplit_HbaseTrxDCommit.csv"));

    TransactionState[] tState = new TransactionState[numtx];
    int[] tStatus = new int[numtx];
    TransactionState transactionState;
    int newValue;

    for (int i = 0; i < 10; i++) {

      long ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        transactionState = transactionManager.beginTransaction();
        tState[newValue] = transactionState;
      }
      long ts2 = System.nanoTime();
      long latency = ts2 - ts1;
      double latency2 = (double) latency / 1000000000.0;
      beg.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        table.put(
            tState[newValue],
            new Put(ROW1).add(FAMILY, Bytes.toBytes(newValue), Bytes.toBytes(newValue)));
        table.put(
            tState[newValue],
            new Put(ROW2).add(FAMILY, Bytes.toBytes(newValue), Bytes.toBytes(newValue)));
        boolean lv_cp_result =
            table.checkAndPut(
                tState[newValue],
                ROW1,
                FAMILY,
                Bytes.toBytes(newValue),
                Bytes.toBytes(newValue),
                new Put(ROW1).add(FAMILY, Bytes.toBytes(newValue), Bytes.toBytes("Trafodion")));
        LOG.debug(
            "Transaction State: "
                + tState[newValue]
                + "; checkAndPut return status: "
                + lv_cp_result);
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000.0;
      put.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        tStatus[newValue] = transactionManager.prepareCommit(tState[newValue]);
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000.0;
      pcom.println(latency2 + ",");

      ts1 = System.nanoTime();
      for (newValue = 0; newValue < numtx; newValue++) {
        transactionManager.doCommit(tState[newValue]);
      }
      ts2 = System.nanoTime();
      latency = ts2 - ts1;
      latency2 = (double) latency / 1000000000.0;
      dcom.println(latency2 + ",");
    }
    beg.close();
    put.close();
    pcom.close();
    dcom.close();
  }
  protected boolean nextScanner(final boolean done) throws IOException {
    if (LOG.isTraceEnabled()) LOG.trace("nextScanner() -- ENTRY txID: " + ts.getTransactionId());
    if (this.interrupted) {
      if (LOG.isDebugEnabled())
        LOG.debug("nextScanner() resetting connection, txID: " + ts.getTransactionId());
      ttable.resetConnection();
      this.interrupted = false;
    }
    if (this.currentBeginKey != null) {
      if (LOG.isTraceEnabled())
        LOG.trace("nextScanner() currentBeginKey != null txID: " + ts.getTransactionId());
      if (doNotCloseOnLast) close();
      if ((this.currentEndKey == HConstants.EMPTY_END_ROW)
          || Bytes.equals(this.currentEndKey, HConstants.EMPTY_BYTE_ARRAY)
          || checkScanStopRow(this.currentEndKey)
          || done) {
        if (LOG.isTraceEnabled()) LOG.trace("endKey: " + Bytes.toString(this.currentEndKey));
        if (LOG.isTraceEnabled())
          LOG.trace("nextScanner() -- EXIT -- returning false txID: " + ts.getTransactionId());
        this.moreScanners = false;
        return false;
      } else this.currentBeginKey = TransactionManager.binaryIncrementPos(this.currentEndKey, 1);
    } else {
      // First call to nextScanner
      this.currentBeginKey = this.scan.getStartRow();
    }

    this.currentRegion = ttable.getRegionLocation(this.currentBeginKey).getRegionInfo();
    this.currentEndKey = this.currentRegion.getEndKey();

    if (LOG.isTraceEnabled()) LOG.trace("Region Info: " + currentRegion.getRegionNameAsString());
    if (this.currentEndKey != HConstants.EMPTY_END_ROW)
      this.currentEndKey = TransactionManager.binaryIncrementPos(currentRegion.getEndKey(), -1);

    this.closed = false;

    TrxRegionProtos.OpenScannerRequest.Builder requestBuilder = OpenScannerRequest.newBuilder();
    requestBuilder.setTransactionId(ts.getTransactionId());
    requestBuilder.setRegionName(ByteString.copyFromUtf8(currentRegion.getRegionNameAsString()));
    requestBuilder.setScan(ProtobufUtil.toScan(scan));
    TrxRegionProtos.OpenScannerRequest openRequest = requestBuilder.build();
    try {
      CoprocessorRpcChannel channel = ttable.coprocessorService(this.currentBeginKey);
      TrxRegionService.BlockingInterface trxService = TrxRegionService.newBlockingStub(channel);
      TrxRegionProtos.OpenScannerResponse response = trxService.openScanner(null, openRequest);
      String exception = response.getException();
      if (response.getHasException()) {
        String errMsg =
            "nextScanner encountered Exception txID: "
                + ts.getTransactionId()
                + " Exception: "
                + exception;
        LOG.error(errMsg);
        throw new IOException(errMsg);
      }
      this.scannerID = response.getScannerId();
    } catch (ServiceException se) {
      this.interrupted = true;
      String errMsg =
          "OpenScanner error encountered Service Exception, scannerID: "
              + this.scannerID
              + " "
              + se;
      LOG.error(errMsg);
      throw new IOException(errMsg);
    } catch (Throwable e) {
      String errMsg =
          "OpenScanner error on coprocessor call, scannerID: " + this.scannerID + " " + e;
      LOG.error(errMsg);
      throw new IOException(errMsg);
    }
    this.nextCallSeq = 0;
    if (LOG.isTraceEnabled())
      LOG.trace("nextScanner() -- EXIT -- returning true txID: " + ts.getTransactionId());
    return true;
  }