void setExecuted(ThreadInfo ti, Instruction insn) {
      int idx = ti.getId();

      if (covered == null) {
        covered = new BitSet[idx + 1];
      } else if (idx >= covered.length) {
        BitSet[] a = new BitSet[idx + 1];
        System.arraycopy(covered, 0, a, 0, covered.length);
        covered = a;
      }

      if (covered[idx] == null) {
        covered[idx] = new BitSet(mi.getInstructions().length);
      }

      int off = insn.getInstructionIndex();
      covered[idx].set(off);

      if (showBranchCoverage && (insn instanceof IfInstruction)) {
        if (branchTrue == null) {
          branchTrue = new BitSet(mi.getInstructions().length);
          branchFalse = new BitSet(branchTrue.size());
        }
        if (!((IfInstruction) insn).getConditionValue()) {
          branchTrue.set(off);
        } else {
          branchFalse.set(off);
        }
      }
    }
Example #2
0
 /**
  * Transition to the next generation by applying the Conway's Game Of Life rule.
  *
  * <ol>
  *   <li>Any live cell with fewer than two live neighbours dies, as if caused by under-population.
  *   <li>Any live cell with two or three live neighbours lives on to the next generation.
  *   <li>Any live cell with more than three live neighbours dies, as if by overcrowding.
  *   <li>Any dead cell with exactly three live neighbours becomes a live cell, as if by
  *       reproduction.
  * </ol>
  */
 public void nextGeneration() {
   // At each step time, looping all cells in the current generation to apply the rules
   for (int i = 0; i < vertical; i++) {
     for (int j = 0; j < horizontal; j++) {
       byte liveCellNeighbours = countLiveNeighbourCells(i, j);
       // If the cell is dead and have exactly 3 live cells neighbours becomes a live cell
       if (!currentGeneration.get(getIndex(i, j))) {
         if (liveCellNeighbours == 3) {
           tempGeneration.set(getIndex(i, j));
         }
       } else { // If the cell is live cell
         // If live cell with fewer than two live neighbours dies
         // If live cell with more than three live neighbours dies, as if by overcrowding.
         if (liveCellNeighbours < 2 || liveCellNeighbours > 3) {
           tempGeneration.clear(getIndex(i, j));
         } else { // Otherwise, keep the current state of the cell
           tempGeneration.set(getIndex(i, j), currentGeneration.get(getIndex(i, j)));
         }
       }
     }
   }
   // Swap the next generation to the current generation for the next step time
   BitSet bs = currentGeneration;
   currentGeneration = tempGeneration;
   tempGeneration = bs;
 }
 @Override
 public void propagate(int evtmask) throws ContradictionException {
   if (PropagatorEventType.isFullPropagation(evtmask)) {
     if (n2 < n + vars[n].getLB()) {
       fails(); // TODO: could be more precise, for explanation purpose
     }
     buildDigraph();
   }
   digraph.removeNode(n2);
   digraph.removeNode(n2 + 1);
   free.clear();
   for (int i = 0; i < n; i++) {
     if (digraph.getPredOf(i).size() == 0) {
       free.set(i);
     }
   }
   for (int i = n; i < n2; i++) {
     if (digraph.getSuccOf(i).size() == 0) {
       free.set(i);
     }
   }
   int card = repairMatching();
   vars[n].updateUpperBound(card, this);
   if (vars[n].getLB() == card) {
     filter();
   }
   for (int i = 0; i < idms.length; i++) {
     idms[i].unfreeze();
   }
 }
Example #4
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, ResourceJobManager struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   oprot.writeString(struct.resourceJobManagerId);
   oprot.writeI32(struct.resourceJobManagerType.getValue());
   BitSet optionals = new BitSet();
   if (struct.isSetPushMonitoringEndpoint()) {
     optionals.set(0);
   }
   if (struct.isSetJobManagerBinPath()) {
     optionals.set(1);
   }
   if (struct.isSetJobManagerCommands()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetPushMonitoringEndpoint()) {
     oprot.writeString(struct.pushMonitoringEndpoint);
   }
   if (struct.isSetJobManagerBinPath()) {
     oprot.writeString(struct.jobManagerBinPath);
   }
   if (struct.isSetJobManagerCommands()) {
     {
       oprot.writeI32(struct.jobManagerCommands.size());
       for (Map.Entry<JobManagerCommand, String> _iter5 : struct.jobManagerCommands.entrySet()) {
         oprot.writeI32(_iter5.getKey().getValue());
         oprot.writeString(_iter5.getValue());
       }
     }
   }
 }
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, AppInfoResult struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetDeviceId()) {
     optionals.set(0);
   }
   if (struct.isSetFlowNum()) {
     optionals.set(1);
   }
   if (struct.isSetResult()) {
     optionals.set(2);
   }
   if (struct.isSetAppdatainfo()) {
     optionals.set(3);
   }
   oprot.writeBitSet(optionals, 4);
   if (struct.isSetDeviceId()) {
     oprot.writeI32(struct.deviceId);
   }
   if (struct.isSetFlowNum()) {
     oprot.writeI32(struct.flowNum);
   }
   if (struct.isSetResult()) {
     oprot.writeBool(struct.result);
   }
   if (struct.isSetAppdatainfo()) {
     struct.appdatainfo.write(oprot);
   }
 }
Example #6
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, DeadServer struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetServer()) {
     optionals.set(0);
   }
   if (struct.isSetLastStatus()) {
     optionals.set(1);
   }
   if (struct.isSetStatus()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetServer()) {
     oprot.writeString(struct.server);
   }
   if (struct.isSetLastStatus()) {
     oprot.writeI64(struct.lastStatus);
   }
   if (struct.isSetStatus()) {
     oprot.writeString(struct.status);
   }
 }
Example #7
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, MemoryUsage struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetMax()) {
     optionals.set(0);
   }
   if (struct.isSetTotal()) {
     optionals.set(1);
   }
   if (struct.isSetFree()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetMax()) {
     oprot.writeI64(struct.max);
   }
   if (struct.isSetTotal()) {
     oprot.writeI64(struct.total);
   }
   if (struct.isSetFree()) {
     oprot.writeI64(struct.free);
   }
 }
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, CqlPreparedResult struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   oprot.writeI32(struct.itemId);
   oprot.writeI32(struct.count);
   BitSet optionals = new BitSet();
   if (struct.isSetVariable_types()) {
     optionals.set(0);
   }
   if (struct.isSetVariable_names()) {
     optionals.set(1);
   }
   oprot.writeBitSet(optionals, 2);
   if (struct.isSetVariable_types()) {
     {
       oprot.writeI32(struct.variable_types.size());
       for (String _iter210 : struct.variable_types) {
         oprot.writeString(_iter210);
       }
     }
   }
   if (struct.isSetVariable_names()) {
     {
       oprot.writeI32(struct.variable_names.size());
       for (String _iter211 : struct.variable_names) {
         oprot.writeString(_iter211);
       }
     }
   }
 }
Example #9
0
  /**
   * Prob0 precomputation algorithm. i.e. determine the states of an STPG which, with min/max
   * probability 0, reach a state in {@code target}, while remaining in those in @{code remain}.
   * {@code min}=true gives Prob0E, {@code min}=false gives Prob0A.
   *
   * @param stpg The STPG
   * @param remain Remain in these states (optional: null means "all")
   * @param target Target states
   * @param min1 Min or max probabilities for player 1 (true=lower bound, false=upper bound)
   * @param min2 Min or max probabilities for player 2 (true=min, false=max)
   */
  public BitSet prob0(STPG stpg, BitSet remain, BitSet target, boolean min1, boolean min2) {
    int n, iters;
    BitSet u, soln, unknown;
    boolean u_done;
    long timer;

    // Start precomputation
    timer = System.currentTimeMillis();
    if (verbosity >= 1)
      mainLog.println(
          "Starting Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")...");

    // Special case: no target states
    if (target.cardinality() == 0) {
      soln = new BitSet(stpg.getNumStates());
      soln.set(0, stpg.getNumStates());
      return soln;
    }

    // Initialise vectors
    n = stpg.getNumStates();
    u = new BitSet(n);
    soln = new BitSet(n);

    // Determine set of states actually need to perform computation for
    unknown = new BitSet();
    unknown.set(0, n);
    unknown.andNot(target);
    if (remain != null) unknown.and(remain);

    // Fixed point loop
    iters = 0;
    u_done = false;
    // Least fixed point - should start from 0 but we optimise by
    // starting from 'target', thus bypassing first iteration
    u.or(target);
    soln.or(target);
    while (!u_done) {
      iters++;
      // Single step of Prob0
      stpg.prob0step(unknown, u, min1, min2, soln);
      // Check termination
      u_done = soln.equals(u);
      // u = soln
      u.clear();
      u.or(soln);
    }

    // Negate
    u.flip(0, n);

    // Finished precomputation
    timer = System.currentTimeMillis() - timer;
    if (verbosity >= 1) {
      mainLog.print("Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")");
      mainLog.println(" took " + iters + " iterations and " + timer / 1000.0 + " seconds.");
    }

    return u;
  }
Example #10
0
  /** Set the bit at i in this SprayPattern to the value b. */
  public void set(int i, boolean b) {

    // Check i
    if (i < 0 || i >= size) throw new IndexOutOfBoundsException();

    // If our bit at i is already b, there is nothing for us to change
    if (get(i) == b) return; // Otherwise, we know we are going to flip the bit at i

    // Update our count of how many true bits we'll have after we flip the one at i
    if (b) ones++; // The bit at i is false, and we're going to set it to true
    else ones--; // The bit at i is true, and we're going to set it to false

    // Flipping the bit will make this whole SprayPattern false, or true
    if (ones == 0 || ones == size) {

      // Discard our BitSet
      array = null;

      // Flipping the bit will leave us with a mixture of true and false bits
    } else {

      // If we don't have a BitSet, make one
      if (array == null) {
        array = new BitSet(size); // The BitSet starts out all 0s
        if (!b && ones == size - 1)
          array.set(0, size); // If all our bits were true, make array all 1s
      }

      // Flip the bit at i to the given value
      array.set(i, b);
    }
  }
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, QueryFListResult struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetResult()) {
     optionals.set(0);
   }
   if (struct.isSetFiles()) {
     optionals.set(1);
   }
   if (struct.isSetSpare()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetResult()) {
     struct.result.write(oprot);
   }
   if (struct.isSetFiles()) {
     {
       oprot.writeI32(struct.files.size());
       for (FileInfo _iter4 : struct.files) {
         _iter4.write(oprot);
       }
     }
   }
   if (struct.isSetSpare()) {
     oprot.writeI32(struct.spare);
   }
 }
Example #12
0
 /**
  * @return a {@link BitSet} representation of an OR Gate truth table to be passed to the super
  *     constructor.
  */
 private static BitSet createORTruthTable() {
   BitSet truthTable = new BitSet();
   truthTable.set(1);
   truthTable.set(2);
   truthTable.set(3);
   return truthTable;
 }
Example #13
0
  private static void placePhi(MethodNode mth, int regNum, LiveVarAnalysis la) {
    List<BlockNode> blocks = mth.getBasicBlocks();
    int blocksCount = blocks.size();
    BitSet hasPhi = new BitSet(blocksCount);
    BitSet processed = new BitSet(blocksCount);
    Deque<BlockNode> workList = new LinkedList<BlockNode>();

    BitSet assignBlocks = la.getAssignBlocks(regNum);
    for (int id = assignBlocks.nextSetBit(0); id >= 0; id = assignBlocks.nextSetBit(id + 1)) {
      processed.set(id);
      workList.add(blocks.get(id));
    }
    while (!workList.isEmpty()) {
      BlockNode block = workList.pop();
      BitSet domFrontier = block.getDomFrontier();
      for (int id = domFrontier.nextSetBit(0); id >= 0; id = domFrontier.nextSetBit(id + 1)) {
        if (!hasPhi.get(id) && la.isLive(id, regNum)) {
          BlockNode df = blocks.get(id);
          addPhi(df, regNum);
          hasPhi.set(id);
          if (!processed.get(id)) {
            processed.set(id);
            workList.add(df);
          }
        }
      }
    }
  }
    BitSet getHandlers() {
      // this algorithm is a bit subtle - we walk through the code until
      // we hit a forward GOTO (or RETURN). If the insn following the goto is the
      // beginning of a handler, we mark everything up to the jump address
      // as a handler block

      if (handlers == null) {
        BitSet hs = getHandlerStarts();
        Instruction[] code = mi.getInstructions();
        BitSet b = new BitSet(code.length);

        if (!hs.isEmpty()) {
          for (int i = 0; i < code.length; i++) {
            Instruction insn = code[i];
            if (insn instanceof GOTO) {
              GOTO gotoInsn = (GOTO) insn;
              if (!gotoInsn.isBackJump() && hs.get(i + 1)) { // jump around handler
                int handlerEnd = gotoInsn.getTarget().getInstructionIndex();
                for (i++; i < handlerEnd; i++) {
                  b.set(i);
                }
              }
            } else if (insn instanceof ReturnInstruction) { // everything else is handler
              for (i++; i < code.length; i++) {
                b.set(i);
              }
            }
          }
        }

        handlers = b;
      }

      return handlers;
    }
Example #15
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, ConditionalUpdates struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetConditions()) {
     optionals.set(0);
   }
   if (struct.isSetUpdates()) {
     optionals.set(1);
   }
   oprot.writeBitSet(optionals, 2);
   if (struct.isSetConditions()) {
     {
       oprot.writeI32(struct.conditions.size());
       for (Condition _iter98 : struct.conditions) {
         _iter98.write(oprot);
       }
     }
   }
   if (struct.isSetUpdates()) {
     {
       oprot.writeI32(struct.updates.size());
       for (ColumnUpdate _iter99 : struct.updates) {
         _iter99.write(oprot);
       }
     }
   }
 }
Example #16
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, RateData struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetUserID()) {
     optionals.set(0);
   }
   if (struct.isSetPostID()) {
     optionals.set(1);
   }
   if (struct.isSetRatingValue()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetUserID()) {
     oprot.writeI64(struct.userID);
   }
   if (struct.isSetPostID()) {
     oprot.writeI64(struct.postID);
   }
   if (struct.isSetRatingValue()) {
     oprot.writeDouble(struct.ratingValue);
   }
 }
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, TConfigInfo struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetGroup()) {
     optionals.set(0);
   }
   if (struct.isSetName()) {
     optionals.set(1);
   }
   if (struct.isSetValue()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetGroup()) {
     oprot.writeString(struct.group);
   }
   if (struct.isSetName()) {
     oprot.writeString(struct.name);
   }
   if (struct.isSetValue()) {
     oprot.writeString(struct.value);
   }
 }
Example #18
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, AggregationInfo struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetAggregationType()) {
     optionals.set(0);
   }
   if (struct.isSetAggregationParams()) {
     optionals.set(1);
   }
   oprot.writeBitSet(optionals, 2);
   if (struct.isSetAggregationType()) {
     oprot.writeString(struct.aggregationType);
   }
   if (struct.isSetAggregationParams()) {
     {
       oprot.writeI32(struct.aggregationParams.size());
       for (Map.Entry<String, String> _iter31 : struct.aggregationParams.entrySet()) {
         oprot.writeString(_iter31.getKey());
         oprot.writeString(_iter31.getValue());
       }
     }
   }
 }
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, BankGroupThrift struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetId()) {
     optionals.set(0);
   }
   if (struct.isSetGroupType()) {
     optionals.set(1);
   }
   if (struct.isSetBankId()) {
     optionals.set(2);
   }
   if (struct.isSetBankCode()) {
     optionals.set(3);
   }
   oprot.writeBitSet(optionals, 4);
   if (struct.isSetId()) {
     oprot.writeI32(struct.id);
   }
   if (struct.isSetGroupType()) {
     oprot.writeI32(struct.groupType);
   }
   if (struct.isSetBankId()) {
     oprot.writeI32(struct.bankId);
   }
   if (struct.isSetBankCode()) {
     oprot.writeString(struct.bankCode);
   }
 }
Example #20
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, Endpoint struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetIpv4()) {
     optionals.set(0);
   }
   if (struct.isSetPort()) {
     optionals.set(1);
   }
   if (struct.isSetService_name()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetIpv4()) {
     oprot.writeI32(struct.ipv4);
   }
   if (struct.isSetPort()) {
     oprot.writeI16(struct.port);
   }
   if (struct.isSetService_name()) {
     oprot.writeString(struct.service_name);
   }
 }
Example #21
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, TGetOperationStatusResp struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   struct.status.write(oprot);
   BitSet optionals = new BitSet();
   if (struct.isSetOperationState()) {
     optionals.set(0);
   }
   if (struct.isSetSqlState()) {
     optionals.set(1);
   }
   if (struct.isSetErrorCode()) {
     optionals.set(2);
   }
   if (struct.isSetErrorMessage()) {
     optionals.set(3);
   }
   oprot.writeBitSet(optionals, 4);
   if (struct.isSetOperationState()) {
     oprot.writeI32(struct.operationState.getValue());
   }
   if (struct.isSetSqlState()) {
     oprot.writeString(struct.sqlState);
   }
   if (struct.isSetErrorCode()) {
     oprot.writeI32(struct.errorCode);
   }
   if (struct.isSetErrorMessage()) {
     oprot.writeString(struct.errorMessage);
   }
 }
Example #22
0
File: Role.java Project: Leolh/hive
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, Role struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetRoleName()) {
     optionals.set(0);
   }
   if (struct.isSetCreateTime()) {
     optionals.set(1);
   }
   if (struct.isSetOwnerName()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetRoleName()) {
     oprot.writeString(struct.roleName);
   }
   if (struct.isSetCreateTime()) {
     oprot.writeI32(struct.createTime);
   }
   if (struct.isSetOwnerName()) {
     oprot.writeString(struct.ownerName);
   }
 }
Example #23
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, Response struct)
     throws TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetResultType()) {
     optionals.set(0);
   }
   if (struct.isSetResult()) {
     optionals.set(1);
   }
   if (struct.isSetOperationId()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetResultType()) {
     oprot.writeString(struct.ResultType);
   }
   if (struct.isSetResult()) {
     oprot.writeBinary(struct.Result);
   }
   if (struct.isSetOperationId()) {
     oprot.writeString(struct.OperationId);
   }
 }
Example #24
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, Graph struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetNodeType()) {
     optionals.set(0);
   }
   if (struct.isSetRoots()) {
     optionals.set(1);
   }
   if (struct.isSetAdjacencyList()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetNodeType()) {
     oprot.writeI32(struct.nodeType.getValue());
   }
   if (struct.isSetRoots()) {
     {
       oprot.writeI32(struct.roots.size());
       for (String _iter16 : struct.roots) {
         oprot.writeString(_iter16);
       }
     }
   }
   if (struct.isSetAdjacencyList()) {
     {
       oprot.writeI32(struct.adjacencyList.size());
       for (Adjacency _iter17 : struct.adjacencyList) {
         _iter17.write(oprot);
       }
     }
   }
 }
Example #25
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, Result struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetValue()) {
     optionals.set(0);
   }
   if (struct.isSetError()) {
     optionals.set(1);
   }
   if (struct.isSetErrortext()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetValue()) {
     oprot.writeString(struct.value);
   }
   if (struct.isSetError()) {
     oprot.writeI32(struct.error.getValue());
   }
   if (struct.isSetErrortext()) {
     oprot.writeString(struct.errortext);
   }
 }
Example #26
0
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, TCommandTransfer struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   BitSet optionals = new BitSet();
   if (struct.isSetApplicationName()) {
     optionals.set(0);
   }
   if (struct.isSetAgentId()) {
     optionals.set(1);
   }
   if (struct.isSetStartTime()) {
     optionals.set(2);
   }
   if (struct.isSetPayload()) {
     optionals.set(3);
   }
   oprot.writeBitSet(optionals, 4);
   if (struct.isSetApplicationName()) {
     oprot.writeString(struct.applicationName);
   }
   if (struct.isSetAgentId()) {
     oprot.writeString(struct.agentId);
   }
   if (struct.isSetStartTime()) {
     oprot.writeI64(struct.startTime);
   }
   if (struct.isSetPayload()) {
     oprot.writeBinary(struct.payload);
   }
 }
 @Override
 public void write(org.apache.thrift.protocol.TProtocol prot, StorageResourceDescription struct)
     throws org.apache.thrift.TException {
   TTupleProtocol oprot = (TTupleProtocol) prot;
   oprot.writeString(struct.storageResourceId);
   oprot.writeString(struct.hostName);
   BitSet optionals = new BitSet();
   if (struct.isSetStorageResourceDescription()) {
     optionals.set(0);
   }
   if (struct.isSetEnabled()) {
     optionals.set(1);
   }
   if (struct.isSetDataMovementInterfaces()) {
     optionals.set(2);
   }
   oprot.writeBitSet(optionals, 3);
   if (struct.isSetStorageResourceDescription()) {
     oprot.writeString(struct.storageResourceDescription);
   }
   if (struct.isSetEnabled()) {
     oprot.writeBool(struct.enabled);
   }
   if (struct.isSetDataMovementInterfaces()) {
     {
       oprot.writeI32(struct.dataMovementInterfaces.size());
       for (org.apache.airavata.model.data.movement.DataMovementInterface _iter4 :
           struct.dataMovementInterfaces) {
         _iter4.write(oprot);
       }
     }
   }
 }
Example #28
0
    private void equivalent(int p1, int p2) {
      BitSet b = equivalence.get(p1);
      b.set(p2);

      b = equivalence.get(p2);
      b.set(p1);
    }
 @Override
 protected void verifyContentAcceptance(
     EventSequence alpha,
     ItemSet set,
     Vector<Element> alphabet,
     int[] sup,
     ProjectedDB[] projDBs,
     int indProj,
     int sInd,
     int eInd,
     boolean inParallel,
     BitSet visited,
     BitSet accepted) {
   for (int i = 0; i < set.size(); i++) {
     Element el = set.elementAt(i);
     int found = alphabet.indexOf(el);
     if ((-1 != found)) {
       if (!visited.get(found)) {
         visited.set(found);
         accepted.set(found, isAcceptedByRelaxation(alpha, el, inParallel));
       }
       if (accepted.get(found)) {
         if (!projDBs[found].contains(sInd)) sup[found]++;
         projDBs[found].set(sInd, eInd);
       }
     }
   }
 }
  /** Find non-locals variables. Algorithm from Briggs, Cooper, Harvey and Simpson */
  public BitSet findNonLocals() {
    BitSet nonLocals = new BitSet(nbVar);
    BitSet killed = new BitSet(nbVar);
    BitSet emptySet = new BitSet(nbVar);
    for (BasicBlock bb = firstBB; bb != null; bb = bb.getNext()) {
      // clear killed set
      killed.and(emptySet);

      Iterator insts = bb.getInstructions();
      while (insts.hasNext()) {
        QInst inst = (QInst) insts.next();
        QOperandBox[] ops = inst.getUses();
        for (int i = 0; i < ops.length; ++i) {
          QOperand op = ops[i].getOperand();
          if (op instanceof QVar) {
            int r = ((QVar) op).getRegister();
            if (!killed.get(r)) {
              nonLocals.set(r);
            }
          }
        }
        if (inst.defVar()) {
          QOperand op = inst.getDefined().getOperand();
          if (op instanceof QVar) {
            int r = ((QVar) op).getRegister();
            killed.set(r);
          }
        }
      }
    }
    return nonLocals;
  }