程序调试记录（纯自用）

忘是亡心i 2022-05-30 10:07 176阅读 0赞

Stack类测试：  
在测试Stck类型的变量内容是否正确时，经常会通过把所有值pop出来输出的方法，这样容易造成一个问题就是，栈已经被弄空了，以后再用的时候就会是一个空栈。所以，栈类型的变量测试完了以后及的把测试部分注释掉。或者查一下有没有好的方法用来测试栈

2017.11.15  
//逻辑错误：版本v2，更改NodeRank类的rank方法，但是节点排名值得计算结果跟v1版本不一致，  
//修改：map.put(i, t+0.4\*nov(i,j)\*map.get(i));===〉map.put(i, t+0.4\*nov(i,j)\*map.get(j));  
  
  
开始考虑的是用queue存储最终的节点排名，把队列变量以参数的方式传输到finalRank()函数，这样先进先出后来用到映射过程中就可以  
现在又想，就用ArrayList存储，按照value排名，然后下标从1开始遍历，得到跟queue一样的效果。  
  
2017.11.18  
今天需要处理两个图了，由于NodeRank类里面之前把g定义成了static，发现在main里面对g分别用两个图赋值，只按照最后一次赋值的来，而且啊，程序都需运行第一次赋值之后的rank方法。  
  
  
code：  
  
  
System.out.println("这是第一个start");  
NodeRank.g=g2;  
  
  
rank=NodeRank.rank();  
System.out.println("这是第一个rank");  
NodeRank.g=g;  
rank2=NodeRank.rank();  
System.out.println("这是第二个rank");  
  
  
result：  
  
  
这是第一个start  
这是第一个rank  
这是第二个rank  
排名结果：2--0.3479683489497371  
排名结果：0--0.28652638523658425  
排名结果：1--0.20537981498161176  
  
  
  
  
处理：只能是把g定义成普通的,然后再用构造函数初始化g，这样对于不同的图就有了相应的rank类。  
注意-----后来发现，我的测试输出可能是有问题的，所以上面说的g是static时候只按照第二次赋值的说法可能有误，记住退回到v2版本去看看到底是不是只按照最后一次赋值的处理，在v2中，g还是static。由于发现把g定义成非静态处理以后似乎更好所以没有退回去检测。再后来，我发现好像只需要给一个图排序，也就是VNR的图，现在想想弄成静态的也可以，再再后来，又想，是要有多个VNR的，哎哟，问题好像更多了呢。  
  
  
问题：测试的时候发现，会映射到重复的节点上。  
解决：对于物理网络节点，添加一个标志位，已经被映射过的就干脆因为不符合要求而直接不被加入备选项中。这个标志位对于一个网络请求的所有节点映射过程中起作用的，所以要声明在遍历VNR节点之前。  
  
  
主动排查发现：sim这个数组，对于一个VNR中的每一个节点都要进行一次更新，所以一定一定要声明在里面，（代码中有一个声明被注释掉了，可以注意下），这样上次节点的结果才不会影响这次的。  
  
  
结果不理想，排查发现：一个超级大的逻辑错误，我的方法里面，只传入了物理网络而没有虚拟网络，关于虚拟网络只是传入了节点下标和排名值，但是我在方法内部，同时需要获得物理网络cpu和虚拟网络cpu，在我想要虚拟网络cpu的时候，我是用物理网络拓扑的g，还有虚拟网络拓扑的节点下标去查的，这个根本没有任何含义！！傻子傻子傻子！！！  
解决：给方法添加一个参数，传递进去虚拟网络拓扑咯。总感觉还有别的办法，但是哪个更好却不知道了。  
  
  
2017.11.19（main和embedding方法）  
语法问题：方法需要Map类型的变量，传入LinkedHashMap型的提出语法错误。声明和创建的时候都用的LinkedHashMap不行，但是声明用map，初始化用linkedhashmap就行。  
上面说错了，其实是，方法返回一个map型的，我要赋值给一个linkedhashmap的变量l，l被声明成map，初始化成linkedhashmap的时候没毛病，但是声明并初始化成linkedhashmap的时候不行。  
  
  
2017.11.21（Floyd方法）  
问题：在floyd算法里面，把路径入栈再出栈的时候，用的for循环，终止条件是（i<stack.size()），然后在循环里面出栈。一直出问题，忽略了出栈后size是会变得，所以每次测试i的时候，size都不一样  
改正：如果还是用for循环的话，就需要把初始时候的size存储，然后再用做循环终止条件。后来没有用for，而是改用while，在栈非空的时候执行循环。所以对栈来说，似乎while循环更合适一点儿。  
  
  
大改embedding类，EmbedOrder类，  
其中embedorder类，更改了返回类型为link<Map>//  
  
  
  
  
  
  
2017.11.22  
Floyd.java  
在后面的编程中发现，我需要知道floyd计算后整条路径的权重以及这条路径（先计算路径权值，如果权值较小，再去记录路径），所以这一个算法对我来说需要返回两类值：路径list，还有路径权重，临时为了更改方便，决定加入  
int\[\]\[\]用来存储路径权重//这里一定一定要好好改改，待改进

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);
    		}
    	}
    
    }