Java SubstrateNetwork.getVertexCount方法代码示例

import vnreal.network.substrate.SubstrateNetwork; //导入方法依赖的package包/类
@Override
public double estimate(SubstrateNetwork sNetwork, VirtualNetwork vNetwork) {
	
	if (sNetwork.getVertexCount() < vNetwork.getVertexCount())
		return 0;
	
	double cpu = estimateCPU(sNetwork.getVertices(), vNetwork.getVertices());
	double bandwidth = estimateBandwith(sNetwork.getEdges(), vNetwork.getEdges());
	
	if (cpu < 1 || bandwidth < 1)
		return 0;
	
	double result = (cpu * bandwidth);

	return result;
}
 

import vnreal.network.substrate.SubstrateNetwork; //导入方法依赖的package包/类
public static LinkedList<Partition> findAllPartitions(SubstrateNetwork cluster, SubstrateNetwork wholeNetwork) {
	
	LinkedList<Partition> result = new LinkedList<Partition>();
	Collection<SubstrateNode> remainingNodes = cluster.getVertices();
	
	int seenNodes = 0;
	for (Iterator<SubstrateNode> nodeset = remainingNodes.iterator(); nodeset.hasNext(); nodeset = remainingNodes.iterator()) {
		SubstrateNetwork currentCluster = dfs(cluster, nodeset.next());
		result.add(new Partition(currentCluster));
		
		Collection<SubstrateNode> currentClusterNodes = currentCluster.getVertices();
		seenNodes += currentClusterNodes.size();
		if (seenNodes == cluster.getVertexCount()) {
			break;
		}
		
		remainingNodes = vnreal.algorithms.utils.SubgraphBasicVN.Utils.minus(remainingNodes, currentClusterNodes);
	}
	
	if (wholeNetwork != null) {
		for (Partition s1 : result) {

			for (Partition s2 : result) {

				for (SubstrateNode n1 : s1.getSubstrateNetwork().getVertices()) {
					for (SubstrateNode n2 : s2.getSubstrateNetwork().getVertices()) {
						Collection<SubstrateLink> edges = wholeNetwork.findEdgeSet(n1, n2);
						if (edges != null && !edges.isEmpty()) {
							for (SubstrateLink e : edges) {
								if (wholeNetwork.getEndpoints(e).getFirst() == n1) {
									s1.getDirectedEdgesToNeighbors().add(new PartitionConnection(n1.getName(), s1, n2.getName(), s2, e));
								} else {
									s2.getDirectedEdgesToNeighbors().add(new PartitionConnection(n2.getName(), s2, n1.getName(), s1, e));
								}

							}
						}
					}
				}

			}
		}
	}
	
	return result;
}
 

import vnreal.network.substrate.SubstrateNetwork; //导入方法依赖的package包/类
/**
	 * Creates whole Locktree below root
	 * @param parent Parent Tree
	 * @param level Level of Tree
	 * @param delegationNodes the DelegationNodes
	 * @param parentCluster SubstratNetwork of Parent
	 */
	private int getPartitionsTree(LockTree parent, int level, Collection<ClusterHead> delegationNodes,
			SubstrateNetwork parentCluster, int depth) {
		int maxdepth = depth;
		if (parentCluster.getVertexCount() < minPartitionSize) {
			return maxdepth;
		}
		
		Collection<Partition> partitions = partitioningAlgorithm.getPartitions(parentCluster);
		if (partitions != null && partitions.size() > 1) {
			LinkedList<LockTree> children = new LinkedList<LockTree>();
			for (Partition partition : partitions) {
				
				SubstrateNetwork partitionNet = partition.getSubstrateNetwork();
				SubstrateNode clusterhead = Utils.findClusterhead(partitionNet);
				
				ClusterHead clusterHead = null;
				
				if (fullKnowledgeNodesLevel <= level) {
					clusterHead = new FullKnowledgeClusterHead(
							partitionNet,
							false,
							level,
							(delegationNodesLevel == level),
							clusterhead,
							(delegationNodesLevel <= level ? null : delegationNodes),
							embeddingAlgorithmFactory.createInstance(),
							estimationAlgorithm);
					
					//we only need to add Information if the parent is PK
//					if(parent.getClusterHead() instanceof PartialKnowledgeClusterHead) {
//						PartialKnowledgeClusterHead pkn = (PartialKnowledgeClusterHead) parent.getClusterHead();
//						pkn.addChildInfo(clusterHead, new NetworkInformation(partitionNet.getCopy(false, true), partition.getDirectedEdgesToNeighbors()));
//					}
//				} else {
//					clusterHead = new PartialKnowledgeClusterHead(
//							partitionNet.getCopy(false, true),
//							(delegationNodesLevel == level),
//							level,
//							clusterhead,
//							(delegationNodesLevel <= level ? null : delegationNodes),
//							estimationAlgorithm,
//							partitioningAlgorithm,
//							partialLinkmappingAlgorithm,
//							embeddingAlgorithmFactory.createInstance(),
//							partition.getDirectedEdgesToNeighbors());
//					
//					//If we have a PKNode we simply add our the info to the Parent (has to be a PK Node to)
//					((PartialKnowledgeClusterHead)parent.getClusterHead()).addChildInfo(clusterHead, ((PartialKnowledgeClusterHead)clusterHead).getNetInfo().getCopy());
				}
				
				LockTree child = new LockTree("p" + (pCounter++), parent, clusterHead);
				
				if (delegationNodesLevel == level) {
					delegationNodes.add(clusterHead);
				}
				
				// in reality, the next step would be done by "clusterhead".
				if (maxLevel == -1 || level < maxLevel) {
					int d = getPartitionsTree(child, level+1, delegationNodes, partition.getSubstrateNetwork(), depth+1);
					if (d > maxdepth) {
						maxdepth = d;
					}
				}
				
				children.add(child);
			}
			parent.setChildren(children);
		}
		
		return maxdepth;
	}