import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
/**
 * Initializes an index, to be restored from snapshot
 */
private Builder initializeAsRestore(IndexMetaData indexMetaData, SnapshotRecoverySource recoverySource, IntSet ignoreShards, boolean asNew, UnassignedInfo unassignedInfo) {
    assert indexMetaData.getIndex().equals(index);
    if (!shards.isEmpty()) {
        throw new IllegalStateException("trying to initialize an index with fresh shards, but already has shards created");
    }
    for (int shardNumber = 0; shardNumber < indexMetaData.getNumberOfShards(); shardNumber++) {
        ShardId shardId = new ShardId(index, shardNumber);
        IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(shardId);
        for (int i = 0; i <= indexMetaData.getNumberOfReplicas(); i++) {
            boolean primary = i == 0;
            if (asNew && ignoreShards.contains(shardNumber)) {
                // This shards wasn't completely snapshotted - restore it as new shard
                indexShardRoutingBuilder.addShard(ShardRouting.newUnassigned(shardId, primary,
                    primary ? StoreRecoverySource.EMPTY_STORE_INSTANCE : PeerRecoverySource.INSTANCE, unassignedInfo));
            } else {
                indexShardRoutingBuilder.addShard(ShardRouting.newUnassigned(shardId, primary,
                    primary ? recoverySource : PeerRecoverySource.INSTANCE, unassignedInfo));
            }
        }
        shards.put(shardNumber, indexShardRoutingBuilder.build());
    }
    return this;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
/**
 * Initializes an index, to be restored from snapshot
 */
private Builder initializeAsRestore(IndexMetaData indexMetaData, RestoreSource restoreSource, IntSet ignoreShards, boolean asNew, UnassignedInfo unassignedInfo) {
    if (!shards.isEmpty()) {
        throw new IllegalStateException("trying to initialize an index with fresh shards, but already has shards created");
    }
    for (int shardId = 0; shardId < indexMetaData.getNumberOfShards(); shardId++) {
        IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(new ShardId(indexMetaData.getIndex(), shardId));
        for (int i = 0; i <= indexMetaData.getNumberOfReplicas(); i++) {
            if (asNew && ignoreShards.contains(shardId)) {
                // This shards wasn't completely snapshotted - restore it as new shard
                indexShardRoutingBuilder.addShard(ShardRouting.newUnassigned(index, shardId, null, i == 0, unassignedInfo));
            } else {
                indexShardRoutingBuilder.addShard(ShardRouting.newUnassigned(index, shardId, i == 0 ? restoreSource : null, i == 0, unassignedInfo));
            }
        }
        shards.put(shardId, indexShardRoutingBuilder.build());
    }
    return this;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
/**
 * This method computes the pagerank for each vertex and keeps a sample of 
 * the vertices for each colour
 * @param graph
 * @return sample graph
 */
public ObjectObjectOpenHashMap<Integer, BitSet> vertexSample(ColouredGraph graph){

ColouredVerticesMetric colouredVertices = new ColouredVerticesMetric();
ObjectObjectOpenHashMap<BitSet,IntSet> vertices = colouredVertices.getVerticesForEachColour(graph);
PageRank pageRank = graph.getGraph().getPageRanking(random);
ObjectObjectOpenHashMap<Integer, BitSet> sampleVertices = new ObjectObjectOpenHashMap<Integer,BitSet>();

    for (ObjectCursor<BitSet> colour : vertices.keys()) {
        if(!colour.value.isEmpty()){  //change this based on the colour we have for rdf:type ...
            Map<Integer, Double> verticesPageRank = new HashMap<Integer, Double>();

            for (int i = 0; i < vertices.get(colour.value).size(); i++) {
                verticesPageRank.put(vertices.get(colour.value).toArray()[i], pageRank.getRank(vertices.get(colour.value).toArray()[i]));
            }
            //sort vertices based on pagerank and keep only a part of them
            Map<Integer, Double> sortedVerticesPageRank = sortByValues(verticesPageRank,graph,colour.value);   
                
            for(Map.Entry entry: sortedVerticesPageRank.entrySet()){ 
                sampleVertices.put((Integer) entry.getKey(), colour.value);
            }
        }
    }
    return sampleVertices;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
@Test
public void testKeybasedGraphPartitioning() {
    Object[] options = {option(GraphDatabaseConfiguration.IDS_FLUSH), false,
                        option(VertexIDAssigner.PLACEMENT_STRATEGY), PropertyPlacementStrategy.class.getName(),
            option(PropertyPlacementStrategy.PARTITION_KEY), "clusterId"};
    clopen(options);

    int[] groupDegrees = {5,5,5,5,5,5,5,5};
    int numVertices = setupGroupClusters(groupDegrees,CommitMode.PER_VERTEX);

    IntSet partitionIds = new IntHashSet(numVertices); //to track the "spread" of partition ids
    for (int i=0;i<groupDegrees.length;i++) {
        TitanVertex g = getOnlyVertex(tx.query().has("groupid","group"+i));
        int partitionId = -1;
        for (TitanVertex v : g.query().direction(Direction.IN).labels("member").vertices()) {
            if (partitionId<0) partitionId = getPartitionID(v);
            assertEquals(partitionId,getPartitionID(v));
            partitionIds.add(partitionId);
        }
    }
    assertTrue(partitionIds.size()>numPartitions/2); //This is a probabilistic test that might fail
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
private boolean findCondition() {
    IntSet tailNodes = new IntOpenHashSet(program.basicBlockCount());
    for (int tailCandidate : cfg.incomingEdges(head)) {
        if (nodes.contains(tailCandidate)) {
            tailNodes.add(tailCandidate);
        }
    }

    bodyStart = dom.commonDominatorOf(tailNodes.toArray());
    int candidate = bodyStart;
    while (bodyStart != head) {
        int currentCandidate = candidate;
        if (Arrays.stream(exits.toArray()).anyMatch(exit -> dom.dominates(currentCandidate, exit))) {
            break;
        }
        bodyStart = candidate;
        candidate = dom.immediateDominatorOf(candidate);
    }

    return candidate != bodyStart;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
private void propagatePhiUsageInformation() {
    IntDeque worklist = new IntArrayDeque();
    for (int receiverIndex : phisByReceiver.keys().toArray()) {
        if (usedPhis.get(receiverIndex)) {
            worklist.addLast(receiverIndex);
        }
    }

    IntSet visited = new IntOpenHashSet();
    while (!worklist.isEmpty()) {
        int varIndex = worklist.removeFirst();
        if (!visited.add(varIndex)) {
            continue;
        }
        usedPhis.set(varIndex);

        Phi phi = phisByReceiver.get(varIndex);
        if (phi != null) {
            for (Incoming incoming : phi.getIncomings()) {
                if (!visited.contains(incoming.getValue().getIndex())) {
                    worklist.addLast(incoming.getValue().getIndex());
                }
            }
        }
    }
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
public void addEdge(int from, int to) {
    if (to < 0 || from < 0) {
        throw new IllegalArgumentException();
    }
    sz = Math.max(sz, Math.max(from, to) + 1);
    builtGraph = null;
    if (addedEdges.size() == from) {
        addedEdges.add(IntOpenHashSet.from(to));
    } else if (addedEdges.size() <= from) {
        addedEdges.addAll(Collections.nCopies(from - addedEdges.size(), null));
        addedEdges.add(IntOpenHashSet.from(to));
    } else {
        IntSet set = addedEdges.get(from);
        if (set == null) {
            addedEdges.set(from, IntOpenHashSet.from(to));
        } else {
            set.add(to);
        }
    }
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
private void processNodeToNodeTransitionQueue() {
    while (!pendingTransitions.isEmpty()) {
        DependencyNodeToNodeTransition transition = pendingTransitions.remove();
        IntSet pendingTypes = transition.pendingTypes;
        transition.pendingTypes = null;
        if (pendingTypes.size() == 1) {
            DependencyType type = types.get(pendingTypes.iterator().next().value);
            transition.consume(type);
        } else {
            DependencyType[] typesToPropagate = new DependencyType[pendingTypes.size()];
            int index = 0;
            for (IntCursor cursor : pendingTypes) {
                typesToPropagate[index++] = types.get(cursor.value);
            }
            transition.consume(typesToPropagate);
        }
    }
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
/**
 * Initializes a new empty index, to be restored from a snapshot
 */
public Builder initializeAsNewRestore(IndexMetaData indexMetaData, SnapshotRecoverySource recoverySource, IntSet ignoreShards) {
    final UnassignedInfo unassignedInfo = new UnassignedInfo(UnassignedInfo.Reason.NEW_INDEX_RESTORED,
                                                             "restore_source[" + recoverySource.snapshot().getRepository() + "/" +
                                                                 recoverySource.snapshot().getSnapshotId().getName() + "]");
    return initializeAsRestore(indexMetaData, recoverySource, ignoreShards, true, unassignedInfo);
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
public FetchProjector(TransportFetchNodeAction transportFetchNodeAction,
                      ThreadPool threadPool,
                      Functions functions,
                      UUID jobId,
                      int collectPhaseId,
                      Map<TableIdent, FetchSource> fetchSources,
                      List<Symbol> outputSymbols,
                      Map<String, IntSet> nodeReaders,
                      TreeMap<Integer, String> readerIndices,
                      Map<String, TableIdent> indicesToIdents) {
    this.transportFetchNodeAction = transportFetchNodeAction;
    this.threadPool = threadPool;
    this.jobId = jobId;
    this.collectPhaseId = collectPhaseId;
    this.fetchSources = fetchSources;
    this.nodeReaders = nodeReaders;
    this.readerIndices = readerIndices;
    this.indicesToIdents = indicesToIdents;

    FetchRowInputSymbolVisitor rowInputSymbolVisitor = new FetchRowInputSymbolVisitor(functions);

    this.collectRowContext = new FetchRowInputSymbolVisitor.Context(fetchSources);

    List<Input<?>> inputs = new ArrayList<>(outputSymbols.size());
    for (Symbol symbol : outputSymbols) {
        inputs.add(rowInputSymbolVisitor.process(symbol, collectRowContext));
    }

    outputRow = new InputRow(inputs);
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
public FetchProjection(int collectPhaseId,
                       Map<TableIdent, FetchSource> fetchSources,
                       List<Symbol> outputSymbols,
                       Map<String, IntSet> nodeReaders,
                       TreeMap<Integer, String> readerIndices,
                       Map<String, TableIdent> indicesToIdents) {
    this.collectPhaseId = collectPhaseId;
    this.fetchSources = fetchSources;
    this.outputSymbols = outputSymbols;
    this.nodeReaders = nodeReaders;
    this.readerIndices = readerIndices;
    this.indicesToIdents = indicesToIdents;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
public ObjectObjectOpenHashMap<BitSet,Double> vertexColourDistribution(ColouredGraph graph){
    ObjectObjectOpenHashMap<BitSet,Double> distribution = new ObjectObjectOpenHashMap<BitSet,Double>();
    NumberOfVerticesMetric metric = new NumberOfVerticesMetric();
    double gSize = metric.apply(graph);
    
    ColouredVerticesMetric colouredVertices = new ColouredVerticesMetric();
    ObjectObjectOpenHashMap<BitSet, IntSet> map = colouredVertices.getVerticesForEachColour(graph);
    
    for (ObjectCursor<BitSet> colour : map.keys()) {
         distribution.put(colour.value, (map.get(colour.value).size()/gSize));
    }
    return distribution;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
double[] computeColor(CompositeMap compositeMap,
                      List<? extends Domain> domains,
                      IntSet filteredDomains,
                      SignificancePredicate isSignificant,
                      ScoringFunction score,
                      Neighborhood neighborhood,
                      int typeIndex) {
    double[] color = { 0, 0, 0 };
    int[] totalContributions = { 0 };

    Stream<? extends Domain> stream = domains.stream();
    if (filteredDomains != null) {
        stream = stream.filter(d -> filteredDomains.contains(d.getIndex()));
    }

    stream.forEach(domain -> {
        domain.forEachAttribute(j -> {
            if (!isSignificant.test(neighborhood, j) || !compositeMap.isTop(j, typeIndex)) {
                return;
            }

            double opacity = score.get(neighborhood, j);
            double[] attributeColor = Util.multiply(opacity * opacity, domain.getColor());
            Util.addInPlace(attributeColor, color);
            totalContributions[0]++;
        });
    });

    if (totalContributions[0] == 0) {
        return null;
    }

    Util.divideInPlace(totalContributions[0], color);
    return color;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
private void testPartitionSpread(boolean flush, boolean batchCommit) {
    Object[] options = {option(GraphDatabaseConfiguration.IDS_FLUSH), flush};
    clopen(options);

    int[] groupDegrees = {10,15,10,17,10,4,7,20,11};
    int numVertices = setupGroupClusters(groupDegrees,batchCommit?CommitMode.BATCH:CommitMode.PER_VERTEX);

    IntSet partitionIds = new IntHashSet(numVertices); //to track the "spread" of partition ids
    for (int i=0;i<groupDegrees.length;i++) {
        TitanVertex g = getOnlyVertex(tx.query().has("groupid","group"+i));
        assertCount(groupDegrees[i],g.edges(Direction.OUT,"contain"));
        assertCount(groupDegrees[i],g.edges(Direction.IN,"member"));
        assertCount(groupDegrees[i],g.query().direction(Direction.OUT).edges());
        assertCount(groupDegrees[i],g.query().direction(Direction.IN).edges());
        assertCount(groupDegrees[i]*2,g.query().edges());
        for (TitanVertex v : g.query().direction(Direction.IN).labels("member").vertices()) {
            int pid = getPartitionID(v);
            partitionIds.add(pid);
            assertEquals(g, getOnlyElement(v.query().direction(Direction.OUT).labels("member").vertices()));
            VertexList vlist = v.query().direction(Direction.IN).labels("contain").vertexIds();
            assertEquals(1,vlist.size());
            assertEquals(pid,idManager.getPartitionId(vlist.getID(0)));
            assertEquals(g,vlist.get(0));
        }
    }
    if (flush || !batchCommit) { //In these cases we would expect significant spread across partitions
        assertTrue(partitionIds.size()>numPartitions/2); //This is a probabilistic test that might fail
    } else {
        assertEquals(1,partitionIds.size()); //No spread in this case
    }
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
public static IntSet toIntSet(final byte[] bytes) {
    IntSet bits = new IntHashSet(bytes == null ? 0 : DEFAULT_EXPECTED_ELEMENTS);
    if (bytes != null && bytes.length > 0) {
        for (int i = 0; i < (bytes.length * 8); i++) {
            if ((bytes[i / 8] & (1 << (7 - (i % 8)))) != 0) {
                bits.add(i);
            }
        }
    }
    return bits;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
public ImmutableSet<T> verticiesForIndexes(IntSet indexes) {
    Builder<T> builder = ImmutableSet.builder();
    for (IntCursor index : indexes) {
        builder.add(verticies.get(index.value));
    }
    return builder.build();
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
void postProcess() {
    int[] aliasInstances = new int[aliases.length];
    Arrays.fill(aliasInstances, -1);
    for (int i = 0; i < aliases.length; ++i) {
        int alias = aliases[i];
        if (aliasInstances[alias] < 0) {
            aliasInstances[alias] = i;
        }
    }

    for (Assertion assertion : assertions) {
        IntSet items = arrayContent[assertion.array];
        if (items != null) {
            Set<String> expectedClasses = new HashSet<>();
            for (int item : items.toArray()) {
                ValueType constant = classConstants[item];
                if (constant != null) {
                    String expectedClass;
                    if (constant instanceof ValueType.Object) {
                        expectedClass = ((ValueType.Object) constant).getClassName();
                    } else {
                        expectedClass = constant.toString();
                    }
                    expectedClasses.add(expectedClass);
                }
            }
            assertion.expectedTypes = expectedClasses.toArray(new String[0]);
        } else {
            assertion.expectedTypes = new String[0];
        }

        assertion.value = aliasInstances[assertion.value];
    }
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
private boolean tryInvert() {
    if (shouldSkip) {
        postponed = true;
        return false;
    }

    if (!findCondition() || bodyStart < 0) {
        return false;
    }

    IntSet nodesToCopy = nodesToCopy();
    NullnessInformation nullness = NullnessInformation.build(program, method.getDescriptor());
    boolean profitable = isInversionProfitable(nodesToCopy, nullness);
    nullness.dispose();
    if (!profitable) {
        return false;
    }
    copyBasicBlocks(nodesToCopy);

    copyCondition();
    moveBackEdges();
    removeInternalPhiInputsFromCondition();
    removeExternalPhiInputsFromConditionCopy();

    changed = true;
    return true;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
private boolean isInversionProfitable(IntSet nodesToCopy, NullnessInformation nullness) {
    UsageExtractor useExtractor = new UsageExtractor();
    DefinitionExtractor defExtractor = new DefinitionExtractor();
    LoopInvariantAnalyzer invariantAnalyzer = new LoopInvariantAnalyzer(nullness);
    for (int node : nodes.toArray()) {
        if (nodesToCopy.contains(node)) {
            continue;
        }
        BasicBlock block = program.basicBlockAt(node);
        Set<Variable> currentInvariants = new HashSet<>();
        for (Instruction insn : block) {
            invariantAnalyzer.reset();
            insn.acceptVisitor(invariantAnalyzer);
            if (!invariantAnalyzer.canMove && !invariantAnalyzer.constant) {
                continue;
            }
            insn.acceptVisitor(useExtractor);
            boolean invariant = Arrays.stream(useExtractor.getUsedVariables()).allMatch(var -> {
                if (currentInvariants.contains(var)) {
                    return true;
                }
                BasicBlock definedAt = var.getIndex() < definitionPlaces.length
                        ? definitionPlaces[var.getIndex()]
                        : null;
                return definedAt == null || dom.dominates(definedAt.getIndex(), head);
            });
            if (invariant) {
                if (invariantAnalyzer.sideEffect) {
                    return true;
                }
                insn.acceptVisitor(defExtractor);
                currentInvariants.addAll(Arrays.asList(defExtractor.getDefinedVariables()));
            }
        }
    }
    return false;
}
 

import com.carrotsearch.hppc.IntSet; //导入依赖的package包/类
private void copyBasicBlocks(IntSet nodesToCopy) {
    int[] nodes = this.nodes.toArray();
    Arrays.sort(nodes);
    for (int node : nodes) {
        nodesAndCopies.add(node);
        if (nodesToCopy.contains(node)) {
            int copy = program.createBasicBlock().getIndex();
            if (head == node) {
                headCopy = copy;
            }
            copiedNodes.put(node, copy);
            nodesAndCopies.add(copy);
        }
    }
}