embedding方法，需要返回两类值，节点间的对应关系以及链路间的对应关系。现在打算用返回类型返回节点间的对应关系，用参数引用的方式返回链路间的对应关系。后期的改进中，要把这两类数值存储到txt里面，如果是一个txt的话，一行内容，表示 虚拟起始、虚拟终止、物理起始、物理终止、物理路径
2017.11.23
启发：
如果想要在一个方法里面返回多种数据，可以考虑把结果写成一个数据类型啊，里面的成员变量就是你要的多个结果
感受：初期留下的“小将就”，在后面都是“大麻烦”，教训教训啊！！！
2017.11.24
经验：什么样的变量没有被初始化才会被报错？
An：如果，你的变量定义了，没有初始值，后面首次用它是为了给他赋值，也就是在等号的左边，那么就没关系
但是如果你没有给他初值，而且还没有让他被赋值，就开始让他作为方法参数或者放在等号右边，那么就会报错。一种情况，即使你赋值了，如果没有跟后面用到的地方在一个代码块里，有可能也报错，比如，在if==0的时候赋值，在if==1的时候使用变量，就会报错。变量一旦被放入if里面再赋值的话，除非所有的if都有赋值语句，不然在if外面用的话就会被报错。
局部变量要先给赋初值才能进行使用，成员变量可以不赋初值，它有默认值，但是局部变量在声明的时候最好给赋初值。要不会出现编译错误
，JAVA局部变量都必须给初始值的
下面例子
for(Map.Entry<Integer, Double>e:embOrder.entrySet()) {
int firstSel;//用于存储第一个VNR节点对应的物理节点
int lastSel;//用于存储上一个VNR节点对应的物理节点
List<Integer> pathSel;//某对被选中的节点最终被选中的路径
int pathLength=5000;//用于存储对应的物理路径的长度,待改进，这里的；路径长度选的是长度上线，直接用5000不好
boolean[] fTemp=new boolean[pn.getNumOfNode()];//用于标志这个节点在回退过程中，有么有被映射过
if(t==0) {
entryFirst=e;
}
if(t==1) {
entry=e;
int firsTemp;//用于临时存储第一个虚拟节点某次被选中的物理节点
int lasTemp;//用于临时存储某个虚拟节点被临时选中的物理节点
List<Integer> pathTemp=new LinkedList<Integer>();//用于存储被临时选中的路径；
for(int j=0;j<3;j++){
{
double[] sim=new double[pn.getNumOfNode()];//待改进：这里不好。这个数组肯定用不到这么大，++但是，每个i都有可能被记录，所以用这么大的数组是可以的。
for(int i=0;i<pn.getNumOfNode();i++){
if(!f[i] && pn.getCpu(i)>=vn.getCpu(entryFirst.getKey())){//物理网络节点cpu大于VNR节点cpu
System.out.println("embedding__new__待映射点1与物理节点中满足要求的节点"+i+"的相似度:"+Similarity.cos(vn.getNode(entryFirst.getKey()),pn.getNode(i)));
sim[i]=Similarity.cos(vn.getNode(entryFirst.getKey()),pn.getNode(i));
//
g.getCpu(i)>g.getCpu(entryFirst.getKey()))
}
}
firsTemp=ProbabilitySelected.proSelected(sim);
fTemp[firsTemp]=true;
System.out.println("此次选中节点"+firsTemp);
}
/*启发：这里用了两个程序块，因为一个待映射节点对应一个sim数组，这个数组在存储的时候我是用节点下标作为数组下标的，为了不让上一次被允许的几点的sim值影响下一个节点的值，
* 所以sim这个数组，对于每一个待映射节点 都需要从空的数组开始，可以每次用之前更新赋值为0，但是我选择了使用俩程序块，在每个块里定义数组，这样更新，*/
{
double[] sim=new double[pn.getNumOfNode()];//待改进：这里不好。这个数组肯定用不到这么大，++但是，每个i都有可能被记录，所以用这么大的数组是可以的。
for(int i=0;i<pn.getNumOfNode();i++){
if(!fTemp[i] && !f[i] && pn.getCpu(i)>=vn.getCpu(entry.getKey())){//物理网络节点cpu大于VNR节点cpu
System.out.println("embedding__new__待映射点2与物理节点中满足要求的节点"+i+"的相似度:"+Similarity.cos(vn.getNode(entry.getKey()),pn.getNode(i)));
sim[i]=Similarity.cos(vn.getNode(entry.getKey()),pn.getNode(i));
//
g.getCpu(i)>g.getCpu(entry.getKey()))
}
}
lasTemp=ProbabilitySelected.proSelected(sim);
System.out.println("此次选中节点："+lasTemp);
}
if(pathLength>Floyd.floyd(pn, firsTemp, lasTemp, pathTemp)) {//如果新得到的路径长度小，那么就存储这个新的路径对应的起始终止节点，以及路径
pathLength=Floyd.floyd(pn, firsTemp, lasTemp, pathTemp);
firstSel=firsTemp;
lastSel=lasTemp;
pathSel=pathTemp;
}
/*在这里就可以把映射结果加入到map里面啦*/
emb.put(entryFirst.getKey(), firstSel);
emb.put(entry.getKey(), lastSel);
}
}
}
经验：关于变量定义的位置，
他会影响循环的次数，在循环中还会影响是不是能把前面得到的值传递给后面，如果想传递，一定要定义到循环的外面。
41、42行和74、75行
package vnr.main;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import vnr.bandit.Embedding;
import vnr.graph.CreateGraph;
import vnr.graph.Edge;
import vnr.graph.Graph;
import vnr.graph.Node;
import vnr.rank.EmbedOrder;
import vnr.rank.NodeRank;
public class embedThread implements Runnable {
String folder;
Graph gPhy;
/**
* @param folderName 存储VNR的文件夹
* @param g 待映射的物理网络拓扑
* */
public embedThread(String folderName,Graph g) {
// TODO Auto-generated constructor stub
folder=folderName;
gPhy=g;
}
@Override
public void run() {
// TODO Auto-generated method stub
int nodeNumPhy=-1,edgeNumPhy=-1;
int nodeNumVir=-1,edgeNumVir=-1;//改进：这里好像用不到两个变量，物理网络和虚拟网络可以用同一对变量。
// LinkedHashMap<Integer,Double> embOrder =new LinkedHashMap<Integer,Double>();//最终映射顺序
// LinkedHashMap<Integer,Integer> result=new LinkedHashMap<Integer,Integer>();
int sucCount=0;
int failCount=0;
try {
// BufferedReader phyReader=new BufferedReader(new FileReader("sub.txt"));
Embedding embeder = new Embedding(".\\Result");
String line;
String regex=" ";
String[] lineContent;
List<String> lines=new LinkedList<String>();
/*虚拟网络相关变量*/
Edge[] edgeVir=null;
Node[] nodeVir=null;
Graph gVir=null;
//网络映射相关变量：noderank
List<Map.Entry<Integer,Double>> rank=new ArrayList<Map.Entry<Integer,Double>>();//VNR
/*虚拟网络topo处理，把表示虚拟网络拓扑的文件存为Graph*/
File demo = new File(folder);
File[] vnrs=demo.listFiles();
for(int j=0;j<vnrs.length;j++) {
BufferedReader virReader = new BufferedReader(new InputStreamReader(new FileInputStream(vnrs[j])));
LinkedHashMap<Integer,Double> embOrder =new LinkedHashMap<Integer,Double>();//最终映射顺序
LinkedHashMap<Integer,Integer> result=new LinkedHashMap<Integer,Integer>();
//启发：本来这两个变量的定义是在上面，但是运行的时候出现数组越界异常，debug发现result的似乎不太对，所以怀疑是前面对变量的赋值影响了后面
//试图调整变量定义的位置，使得每个虚拟网络请求都有自己的排序变量，所以放到for里面创建，果然不再出现异常
lines.clear();
while((line=virReader.readLine())!=null) {
lines.add(line);
}
for(int i=0;i<lines.size();i++) {
lineContent=lines.get(i).split(regex);
if(lineContent.length==2) {
nodeNumVir=Integer.parseInt(lineContent[0]);
edgeNumVir=Integer.parseInt(lineContent[1]);
edgeVir=new Edge[edgeNumVir];
nodeVir=new Node[nodeNumVir];
gVir=new Graph(nodeNumVir);
}else if(lineContent.length==1) {
nodeVir[i-1]=new Node(Double.parseDouble(lineContent[0]));
}else {
edgeVir[i-1-nodeNumVir]=new Edge(Integer.parseInt(lineContent[0]),Integer.parseInt(lineContent[1]),
Double.parseDouble(lineContent[2]));
}
}
CreateGraph.create(gVir, nodeVir, nodeNumVir, edgeVir, edgeNumVir);
/*计算节点排名以及映射顺序*/
NodeRank nr=new NodeRank(gVir);
rank=nr.rank();
for(int u=0;u<rank.size();u++) {
System.out.println(rank.get(u).getKey()+"-"+rank.get(u).getValue());
}
embOrder=EmbedOrder.embOrder(rank,gVir);
/*节点映射+链路映射*/
switch (embeder.embedding(embOrder, result, gVir, gPhy,j)) {
case 1://节点映射成功则进行链路映射
switch (embeder.embLink(gVir, gPhy, result,j)) {
case 1://链路映射成功
sucCount++;
break;
case -1://等待补充:映射失败后除了统计失败数量,还需要把被这个失败映射占用的资源恢复回来
failCount++;
break;
default:
break;
}
break;
case -1://等待补充:映射失败后除了统计失败数量,还需要把被这个失败映射占用的资源恢复回来
failCount++;
default:
break;
}
System.out.println("成功映射数目："+sucCount);
System.out.println("失败映射数目："+failCount);
}
} catch (Exception e) {
// TODO: handle exception
System.out.println("FROM embedThread.java-"+e);
}
}
}
