diff --git a/src/main/java/com/hy/java/uct/sdtocode/SDToCodeTracer.java b/src/main/java/com/hy/java/uct/sdtocode/SDToCodeTracer.java index cdfdd34f61f04cb5214182a98d9ec9547f1b5cde..8b654999fe977045663bdbfc5f4d7f49de4dcccb 100644 --- a/src/main/java/com/hy/java/uct/sdtocode/SDToCodeTracer.java +++ b/src/main/java/com/hy/java/uct/sdtocode/SDToCodeTracer.java @@ -50,9 +50,9 @@ public class SDToCodeTracer { */ // Hadoop HDFS // Pair, List> objs_in_SD = SDReader.read(sd_dir + "sd-Hadoop HDFS1.txt"); - Pair, List> objs_in_SD = SDReader.read(sd_dir + "sd-Hadoop HDFS2.txt"); + // Pair, List> objs_in_SD = SDReader.read(sd_dir + "sd-Hadoop HDFS2.txt"); // Hadoop MapReduce - // Pair, List> objs_in_SD = SDReader.read(sd_dir + "sd-Hadoop MapReduce.txt"); + Pair, List> objs_in_SD = SDReader.read(sd_dir + "sd-Hadoop MapReduce.txt"); // 检查结果，可注释掉 // SDReader.check(objs_in_SD); /* @@ -61,17 +61,17 @@ public class SDToCodeTracer { * 将对象分解 */ // Hadoop HDFS - DocReader.readDoc(doc_dir + "Hadoop HDFS\\Hadoop HDFS.xls", objs_in_SD); + // DocReader.readDoc(doc_dir + "Hadoop HDFS\\Hadoop HDFS.xls", objs_in_SD); // Hadoop MapReduce - // DocReader.readDoc(doc_dir + "Hadoop MapReduce\\Hadoop MapReduce.xls", objs_in_SD); + DocReader.readDoc(doc_dir + "Hadoop MapReduce\\Hadoop MapReduce.xls", objs_in_SD); // DocReader.check(objs_in_SD); /* * 3、读取code path指定的目录下所有java文件 * * <类全称（包+类名）, java_file_path> */ - Map classFullName_javaFileDir_map = CodeReader.read(code_dir + "code path-hdfs"); - // Map classFullName_javaFileDir_map = CodeReader.read(code_dir + "code path-mr"); + // Map classFullName_javaFileDir_map = CodeReader.read(code_dir + "code path-hdfs"); + Map classFullName_javaFileDir_map = CodeReader.read(code_dir + "code path-mr"); // 检查结果，可注释掉 // CodeReader.check(classFullName_javaFileDir_map); /* @@ -88,10 +88,9 @@ public class SDToCodeTracer { */ List traced_msgs = CodeMessageTracer.trace(objs_in_SD, classFullName_javaFileDir_map); // Hadoop HDFS - CodeMessageTracer.save(traced_msgs, res_dir + "Hadoop HDFS.xls"); + // CodeMessageTracer.save(traced_msgs, res_dir + "Hadoop HDFS1.xls"); + // CodeMessageTracer.save(traced_msgs, res_dir + "Hadoop HDFS2.xls"); // Hadoop MapReduce - // CodeRelationMapper.save(traced_msgs, res_dir + "Hadoop MapReduce.xls"); - // 检查结果，可注释掉 - // CodeRelationMapper.check(res_dir + "Hadoop HDFS.xls"); + CodeMessageTracer.save(traced_msgs, res_dir + "Hadoop MapReduce.xls"); } } diff --git a/src/main/java/com/hy/java/uct/sdtocode/mapper/CodeMessageTracer.java b/src/main/java/com/hy/java/uct/sdtocode/mapper/CodeMessageTracer.java index b3f3ea2d29bf45d1fda55ab0cbc7d1091cd175a8..b748632cb3b63e6325b051f0ab82bf9f7a75dcc8 100644 --- a/src/main/java/com/hy/java/uct/sdtocode/mapper/CodeMessageTracer.java +++ b/src/main/java/com/hy/java/uct/sdtocode/mapper/CodeMessageTracer.java @@ -2,7 +2,10 @@ package com.hy.java.uct.sdtocode.mapper; import java.io.File; import java.io.FileNotFoundException; +import java.io.IOException; import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; @@ -20,12 +23,20 @@ import com.github.javaparser.ast.body.FieldDeclaration; import com.github.javaparser.ast.body.MethodDeclaration; import com.github.javaparser.ast.body.Parameter; import com.github.javaparser.ast.stmt.BlockStmt; -import com.hy.java.uct.sdtocode.util.TracedMessagePath; +import com.hy.java.uct.sdtocode.util.MessageTracedLink; import com.hy.java.uct.util.sd.Message; import com.hy.java.uct.util.sd.UMLObject; import com.hy.java.utility.common.Pair; import com.hy.java.utility.common.Traverser; import com.hy.java.utility.common.Traverser.FileNode; + +import jxl.Workbook; +import jxl.write.Label; +import jxl.write.WritableSheet; +import jxl.write.WritableWorkbook; +import jxl.write.WriteException; +import jxl.write.biff.RowsExceededException; + import com.hy.java.utility.common.Triple; /** @@ -352,9 +363,9 @@ public class CodeMessageTracer { } if (max_codeLine_sim >= 0.625) { // 把这句代码记下来作为msg_inSD的追踪结果之一 - TracedMessagePath trace_path = new TracedMessagePath(); - trace_path.path.add(Triple.createTriple(uo_mapped_file_dir, code_line.trim(), attri_name_similarity * max_codeLine_sim)); - msg_inSD.traced_path_ls.add(trace_path); + MessageTracedLink trace_path = new MessageTracedLink(); + trace_path.identifiers.add(Triple.createTriple(uo_mapped_file_dir, code_line.trim(), attri_name_similarity * max_codeLine_sim)); + msg_inSD.traced_link_ls.add(trace_path); } } } @@ -446,9 +457,9 @@ public class CodeMessageTracer { // 这个阈值可以再改 if (sim > 0.5) { // 把这句代码记下来作为msg_inSD的追踪结果之一 - TracedMessagePath trace_path = new TracedMessagePath(); - trace_path.path.add(Triple.createTriple(attri_clsCode.getLeft(), md.getDeclarationAsString().trim(), attri_name_sim * sim)); - msg_inSD.traced_path_ls.add(trace_path); + MessageTracedLink trace_path = new MessageTracedLink(); + trace_path.identifiers.add(Triple.createTriple(attri_clsCode.getLeft(), md.getDeclarationAsString().trim(), attri_name_sim * sim)); + msg_inSD.traced_link_ls.add(trace_path); } } System.out.println("检查完支撑类" + clsCode_unit.getNameAsString() + "中属性" + sim_attri.getVariable(0).getNameAsString() + "的类型实现类中所有方法与" + msg + "的相似度了"); @@ -496,9 +507,9 @@ public class CodeMessageTracer { * 2）计算每个方法与消息内容的语义相似度。找到相似的方法。 */ for (Triple tri : method_code_sim) { - double sim = jaccard_similarity(tri.getLeft().getNameAsString(), method_in_msg); + double sim = jaccard_similarity(tri.getLeft().getNameAsString().toLowerCase(), method_in_msg.toLowerCase()); // 这个阈值可以再改 - if (sim > 0.5) { + if (sim >= 0.5) { tri.setRight(sim); } } @@ -508,7 +519,7 @@ public class CodeMessageTracer { * ②对与消息相似的方法，找到其所属的类，在这个类里看该方法的返回类型是否与另一端相似。 */ for (Triple tri : method_code_sim) { - if (tri.getRight() > 0.5) { + if (tri.getRight() >= 0.5) { // ①找该方法内是否有对消息另一端的调用，如参数、方法内的变量、语句等。 checkIfCall(tri, target_uo.getTitle(), msg_inSD, uo_mapped_file_dir); // ②对与消息相似的方法，找到其所属的类，在这个类里看该方法的返回类型是否与另一端相似。 @@ -629,12 +640,17 @@ public class CodeMessageTracer { for (MethodDeclaration _method : methods) { res.add(Triple.createTriple(_method, _method.getDeclarationAsString(), 0.0)); } - for (Pair method_in_codeLine : methods_in_codeLine) { - for (MethodDeclaration method_in_importAndPackage : methods_in_importAndPackage) { + for (MethodDeclaration method_in_importAndPackage : methods_in_importAndPackage) { + boolean used_in_methods = false; + for (Pair method_in_codeLine : methods_in_codeLine) { if (method_in_codeLine.getRight().equals(method_in_importAndPackage.getNameAsString())) { res.add(Triple.createTriple(method_in_importAndPackage, method_in_codeLine.getLeft(), 0.0)); + used_in_methods = true; } } + if (!used_in_methods) { + res.add(Triple.createTriple(method_in_importAndPackage, method_in_importAndPackage.toString(), 0.0)); + } } return res; } @@ -675,10 +691,10 @@ public class CodeMessageTracer { */ // 这个阈值可以再改 if (parameter_sim > 0.3 || codeLine_sim > 0.3) { - TracedMessagePath trace_path = new TracedMessagePath(); + MessageTracedLink trace_path = new MessageTracedLink(); double max = parameter_sim > codeLine_sim ? parameter_sim : codeLine_sim; - trace_path.path.add(Triple.createTriple(uo_mapped_file_dir, tri.getMid().trim(), tri.getRight() * max)); - msg_inSD.traced_path_ls.add(trace_path); + trace_path.identifiers.add(Triple.createTriple(uo_mapped_file_dir, tri.getMid().trim(), tri.getRight() * max)); + msg_inSD.traced_link_ls.add(trace_path); } } @@ -687,12 +703,50 @@ public class CodeMessageTracer { */ private static void checkIfReturn(Triple tri, String target_title, Message msg_inSD, String uo_mapped_file_dir) { MethodDeclaration md = tri.getLeft(); + String return_type = md.getTypeAsString(); + if (return_type.contains(".")) { + return_type = return_type.substring(return_type.lastIndexOf(".") + 1); + } + boolean return_similar = false; + // 看返回类型是否与另一端相似 double returnType_sim = jaccard_similarity(md.getTypeAsString(), target_title); // 这个阈值可以再改 if (returnType_sim > 0.5) { - TracedMessagePath trace_path = new TracedMessagePath(); - trace_path.path.add(Triple.createTriple(uo_mapped_file_dir, tri.getMid().trim(), tri.getRight() * returnType_sim)); - msg_inSD.traced_path_ls.add(trace_path); + return_similar = true; + } + /* + * 另一种情况：对比返回消息中的返回类型 + * + * 对于返回类型为org.xxx.JobID和对应返回消息jobId这种类型的识别 + */ + else { + if (msg_inSD.return_msg != null) { + returnType_sim = jaccard_similarity(return_type.toLowerCase(), msg_inSD.return_msg.msg.toLowerCase()); + if (returnType_sim > 0.5) { + return_similar = true; + } + } + } + // 如果返回类型不像，但名称过于相似，则也认为是追踪 + if (!return_similar) { + String msg_pure_methodName = msg_inSD.msg; + if (msg_inSD.msg.contains("(")) { + msg_pure_methodName = msg_inSD.msg.substring(0, msg_inSD.msg.lastIndexOf("(")); + + } + if (md.getNameAsString().toLowerCase().contains(msg_pure_methodName.toLowerCase())) { + returnType_sim = 1.0; + } else { + returnType_sim = jaccard_similarity(md.getNameAsString().toLowerCase(), msg_pure_methodName.toLowerCase()); + } + if (returnType_sim >= 0.75) { + return_similar = true; + } + } + if (return_similar) { + MessageTracedLink trace_path = new MessageTracedLink(); + trace_path.identifiers.add(Triple.createTriple(uo_mapped_file_dir, tri.getMid().trim(), tri.getRight() * returnType_sim)); + msg_inSD.traced_link_ls.add(trace_path); } } @@ -849,7 +903,7 @@ public class CodeMessageTracer { */ System.out.println("对于" + msg_inSD.msg + "，将由标识符链接起来的链条作为消息的追踪"); // 按照identifier的顺序保存多个traced_path - List temp_tracedPath_startingFromID = new ArrayList<>(); + List temp_tracedPath_startingFromID = new ArrayList<>(); int traced_identifiers_num = index_clsFilePath_ls.size(); int id_index = 0; do { @@ -857,22 +911,22 @@ public class CodeMessageTracer { if (id_index == 0) { List, ClassOrInterfaceDeclaration>> tracedFiles_for_firstIdentifier = index_clsFilePath_ls.get(id_index); for (Triple, ClassOrInterfaceDeclaration> a_tracedFile_for_firstIdentifier : tracedFiles_for_firstIdentifier) { - TracedMessagePath traced_path = new TracedMessagePath(); - traced_path.path.add(a_tracedFile_for_firstIdentifier.getMid()); + MessageTracedLink traced_path = new MessageTracedLink(); + traced_path.identifiers.add(a_tracedFile_for_firstIdentifier.getMid()); temp_tracedPath_startingFromID.add(traced_path); } } // 后面标识符的每个追踪文件都得在前面的一个TracedMessagePath后出现一次 else { int temp_tracedPath_currentSize = temp_tracedPath_startingFromID.size(); - List tmp_record_tracedPath = new ArrayList<>(); + List tmp_record_tracedPath = new ArrayList<>(); for (int j = 0; j < temp_tracedPath_currentSize; j++) { - TracedMessagePath Jth_tracedPath_till_formerID = temp_tracedPath_startingFromID.get(j); + MessageTracedLink Jth_tracedPath_till_formerID = temp_tracedPath_startingFromID.get(j); List, ClassOrInterfaceDeclaration>> tracedFiles_for_currentIdentifier = index_clsFilePath_ls.get(id_index); for (Triple, ClassOrInterfaceDeclaration> a_tracedFile_for_currentIdentifier : tracedFiles_for_currentIdentifier) { - TracedMessagePath new_ttp = new TracedMessagePath(); - new_ttp.path.addAll(Jth_tracedPath_till_formerID.path); - new_ttp.path.add(a_tracedFile_for_currentIdentifier.getMid()); + MessageTracedLink new_ttp = new MessageTracedLink(); + new_ttp.identifiers.addAll(Jth_tracedPath_till_formerID.identifiers); + new_ttp.identifiers.add(a_tracedFile_for_currentIdentifier.getMid()); tmp_record_tracedPath.add(new_ttp); } } @@ -881,7 +935,7 @@ public class CodeMessageTracer { } id_index++; } while (id_index < traced_identifiers_num); - msg_inSD.traced_path_ls.addAll(temp_tracedPath_startingFromID); + msg_inSD.traced_link_ls.addAll(temp_tracedPath_startingFromID); /* * 3）对比链条两端与消息两端的对象。如果存在支撑类之类的关系，则认为消息两端应该是支撑类；否则仍保留链条两端作为消息两端。 * @@ -1062,18 +1116,137 @@ public class CodeMessageTracer { /** * 整理、保存追踪结果 */ - public static void save(List trace_msgs, String res_dir) { - for (Message msg : trace_msgs) { - int tracing_ways = msg.traced_path_ls.size(); - for (int i = 0; i < tracing_ways; i++) { - TracedMessagePath tracing_way = msg.traced_path_ls.get(i); - System.out.println(msg.msg + "的第" + (i + 1) + "种追踪链："); - int identifier_num = tracing_way.path.size(); - for (int j = 0; j < identifier_num; j++) { - Triple traced_file = tracing_way.path.get(j); - System.out.println("\t" + msg.msg + "的第" + (j + 1) + "个标识符有" + traced_file.getRight() + "概率追踪到文件" + traced_file.getLeft() + "的代码段" + traced_file.getMid()); + public static void save(List traced_msgs, String res_dir) { + System.out.println("开始整理结果"); + for (Message msg : traced_msgs) { + // 整理后的结果 + List res = new ArrayList<>(); + // 该Map临时对比用：以追踪文件地址为Key，各种不同代码段对应的tracing_way为List + Map> tracedFiles_waysForThisFile = new HashMap<>(); + // 遍历该msg的所有追踪链 + for (MessageTracedLink trace_link : msg.traced_link_ls) { + // 如果追踪链里只有一个标识符，则进行合并 + if (trace_link.identifiers.size() == 1) { + // 当前追踪链里、唯一一个标识符的一个追踪文件 + Triple traced_file = trace_link.identifiers.get(0); + /* + * 如果Map里暂时还没有记录这个追踪文件（traced_file.getLeft()），则记录该追踪文件及对应的追踪链 + */ + if (!tracedFiles_waysForThisFile.containsKey(traced_file.getLeft())) { + List tracingWays_for_this_tracedFile = new ArrayList<>(); + tracingWays_for_this_tracedFile.add(trace_link); + tracedFiles_waysForThisFile.put(traced_file.getLeft(), tracingWays_for_this_tracedFile); + } + /* + * 如果Map里已记录这个追踪文件（traced_file.getLeft()），则对比当前追踪链和已有的代码段是否重复 + */ + else { + // 该追踪文件所拥有的各种不同的追踪代码段 + List tracingWays_for_this_tracedFile = tracedFiles_waysForThisFile.get(traced_file.getLeft()); + boolean already_have_this_code = false; + // 对每个已追踪到的代码段，与traced_file.getMid()对比。若一样，则合并概率 + int traced_codes_num = tracingWays_for_this_tracedFile.size(); + for (int i = 0; i < traced_codes_num; i++) { + MessageTracedLink traced_code = tracingWays_for_this_tracedFile.get(i); + // 如果已经追到过这段代码（该段代码被重复追踪了），则合并概率 + if (traced_code.identifiers.get(0).getMid().equals(traced_file.getMid())) { + already_have_this_code = true; + // 概率合并 + double p = 1 - (1 - traced_code.identifiers.get(0).getRight()) * (1 - traced_file.getRight()); + traced_code.identifiers.get(0).setRight(p); + tracingWays_for_this_tracedFile.set(i, traced_code); + } + } + // 若该段代码是新的，则直接添加进Map即可 + if (!already_have_this_code) { + tracingWays_for_this_tracedFile.add(trace_link); + } + tracedFiles_waysForThisFile.put(traced_file.getLeft(), tracingWays_for_this_tracedFile); + } + } + // 如果追踪链里有多个标识符，则该消息是复杂消息，追踪结果不可能有重复，所以不用合并 + else { + res.add(trace_link); + } + } + Collection> tracedCodes_for_tracedFiles = tracedFiles_waysForThisFile.values(); + for (List tracedCodes_for_tracedFile : tracedCodes_for_tracedFiles) { + res.addAll(tracedCodes_for_tracedFile); + } + msg.traced_link_ls = res; + } + System.out.println("完成整理结果"); + System.out.println("保存结果至" + res_dir); + try { + WritableWorkbook workbook = Workbook.createWorkbook(new File(res_dir)); + if (workbook != null) { + // 新建第一个工作表 + WritableSheet sheet1 = workbook.createSheet("Sheet1", 0); + /* + * 保存结果 + */ + // 构建工作表的表头 + sheet1.addCell(new Label(0, 0, "消息")); + sheet1.addCell(new Label(1, 0, "标签索引")); + sheet1.addCell(new Label(2, 0, "Java文件地址")); + sheet1.addCell(new Label(3, 0, "代码段")); + sheet1.addCell(new Label(4, 0, "追踪概率")); + // 保存追踪链 + int msg_num = traced_msgs.size(); + int row = 1; + for (int msg_index = 0; msg_index < msg_num; msg_index++) { + Message msg = traced_msgs.get(msg_index); + int tracing_ways = msg.traced_link_ls.size(); + for (int i = 0; i < tracing_ways; i++) { + MessageTracedLink tracing_way = msg.traced_link_ls.get(i); + int identifier_num = tracing_way.identifiers.size(); + if (identifier_num > 1) { + for (int j = 0; j < identifier_num; j++) { + Triple traced_file = tracing_way.identifiers.get(j); + sheet1.addCell(new Label(0, row, msg.msg)); + sheet1.addCell(new Label(1, row, String.valueOf(j + 1))); + sheet1.addCell(new Label(2, row, traced_file.getLeft())); + sheet1.addCell(new Label(3, row, traced_file.getMid())); + sheet1.addCell(new Label(4, row, String.valueOf(traced_file.getRight()))); + row++; + } + } else { + for (int j = 0; j < identifier_num; j++) { + Triple traced_file = tracing_way.identifiers.get(j); + // 追踪概率过小的不保存 + if (msg.msg.contains("run")) { + if (traced_file.getRight() >= 0.625) { + sheet1.addCell(new Label(0, row, msg.msg)); + sheet1.addCell(new Label(1, row, String.valueOf(j + 1))); + sheet1.addCell(new Label(2, row, traced_file.getLeft())); + sheet1.addCell(new Label(3, row, traced_file.getMid())); + sheet1.addCell(new Label(4, row, String.valueOf(traced_file.getRight()))); + row++; + } + } else { + if (traced_file.getRight() >= 0.75) { + sheet1.addCell(new Label(0, row, msg.msg)); + sheet1.addCell(new Label(1, row, String.valueOf(j + 1))); + sheet1.addCell(new Label(2, row, traced_file.getLeft())); + sheet1.addCell(new Label(3, row, traced_file.getMid())); + sheet1.addCell(new Label(4, row, String.valueOf(traced_file.getRight()))); + row++; + } + } + } + } + } } + // 写入文件 + workbook.write(); + workbook.close(); } + } catch (RowsExceededException e) { + e.printStackTrace(); + } catch (WriteException e) { + e.printStackTrace(); + } catch (IOException e) { + e.printStackTrace(); } } } diff --git a/src/main/java/com/hy/java/uct/sdtocode/util/TracedMessagePath.java b/src/main/java/com/hy/java/uct/sdtocode/util/MessageTracedLink.java similarity index 80% rename from src/main/java/com/hy/java/uct/sdtocode/util/TracedMessagePath.java rename to src/main/java/com/hy/java/uct/sdtocode/util/MessageTracedLink.java index 127b5e20cc45e8eb751e4e1d5eeec8dce4dedb90..e377b095b8a674d864cc2426da9de9b29b9db5df 100644 --- a/src/main/java/com/hy/java/uct/sdtocode/util/TracedMessagePath.java +++ b/src/main/java/com/hy/java/uct/sdtocode/util/MessageTracedLink.java @@ -12,9 +12,9 @@ import com.hy.java.utility.common.Triple; * * 每条链路有个总体的追踪概率 */ -public class TracedMessagePath { +public class MessageTracedLink { /** * 一条链路：由一系列{@code }组成的List */ - public List> path = new ArrayList<>(); + public List> identifiers = new ArrayList<>(); } diff --git a/src/main/java/com/hy/java/uct/util/sd/Message.java b/src/main/java/com/hy/java/uct/util/sd/Message.java index 75f939e50c7f0fa3938e319cee209414ab2373da..1b30ca68f1214cf46a96755cbb5a2841abc4cf66 100644 --- a/src/main/java/com/hy/java/uct/util/sd/Message.java +++ b/src/main/java/com/hy/java/uct/util/sd/Message.java @@ -3,7 +3,7 @@ package com.hy.java.uct.util.sd; import java.util.ArrayList; import java.util.List; -import com.hy.java.uct.sdtocode.util.TracedMessagePath; +import com.hy.java.uct.sdtocode.util.MessageTracedLink; import com.hy.java.uct.umlrecog.util.Line; import com.hy.java.uct.umlrecog.util.PolygonalLine; @@ -37,7 +37,7 @@ public class Message { * * 每条链路有个总体的追踪概率 */ - public List traced_path_ls = new ArrayList<>(); + public List traced_link_ls = new ArrayList<>(); public Message() { } diff --git a/src/main/resources/sdtocode/Hadoop HDFS1.xls b/src/main/resources/sdtocode/Hadoop HDFS1.xls new file mode 100644 index 0000000000000000000000000000000000000000..a046568c648a0954cf198503579b2475fcc96bef Binary files /dev/null and b/src/main/resources/sdtocode/Hadoop HDFS1.xls differ diff --git a/src/main/resources/sdtocode/Hadoop HDFS2.xls b/src/main/resources/sdtocode/Hadoop HDFS2.xls new file mode 100644 index 0000000000000000000000000000000000000000..49efddcabf7ac8d69c3ea571e0cdecb36834acc9 Binary files /dev/null and b/src/main/resources/sdtocode/Hadoop HDFS2.xls differ diff --git a/src/main/resources/sdtocode/Hadoop MapReduce.xls b/src/main/resources/sdtocode/Hadoop MapReduce.xls new file mode 100644 index 0000000000000000000000000000000000000000..8c201613e28ef9ae3f0c6ecac6f442702d15c970 Binary files /dev/null and b/src/main/resources/sdtocode/Hadoop MapReduce.xls differ diff --git a/src/main/resources/sdtocode/doc/Hadoop MapReduce/Hadoop MapReduce.xls b/src/main/resources/sdtocode/doc/Hadoop MapReduce/Hadoop MapReduce.xls index b28fcdd7b1710bf6526eeb5ca134cd8680467ac4..50e3acdce3007ac4268d5a125ac1f3d1119b6392 100644 Binary files a/src/main/resources/sdtocode/doc/Hadoop MapReduce/Hadoop MapReduce.xls and b/src/main/resources/sdtocode/doc/Hadoop MapReduce/Hadoop MapReduce.xls differ