diff --git a/src/org/ntlab/traceDebugger/CallTreeModel.java b/src/org/ntlab/traceDebugger/CallTreeModel.java
index 82e1af9..ee2a1ff 100644
--- a/src/org/ntlab/traceDebugger/CallTreeModel.java
+++ b/src/org/ntlab/traceDebugger/CallTreeModel.java
@@ -9,6 +9,8 @@
 public class CallTreeModel {
 	private MethodExecution methodExecution;
 	private boolean isHighlighting;
+	private CallTreeModel parent;
+	private List<CallTreeModel> children = new ArrayList<>();
 	
 	public CallTreeModel(MethodExecution methodExecution) {
 		this.methodExecution = methodExecution;
@@ -51,12 +53,28 @@
 		this.isHighlighting = isHighlighting;
 	}
 
+//	public List<CallTreeModel> getChildren() {
+//		List<MethodExecution> children = methodExecution.getChildren();
+//		List<CallTreeModel> childrenCallTreeModels = new ArrayList<>();
+//		for (MethodExecution child : children) {
+//			childrenCallTreeModels.add(new CallTreeModel(child));
+//		}
+//		return childrenCallTreeModels;
+//	}
+	
+	public CallTreeModel getParent() {
+		return parent;
+	}
+	
 	public List<CallTreeModel> getChildren() {
-		List<MethodExecution> children = methodExecution.getChildren();
-		List<CallTreeModel> childrenCallTreeModels = new ArrayList<>();
-		for (MethodExecution child : children) {
-			childrenCallTreeModels.add(new CallTreeModel(child));
-		}
-		return childrenCallTreeModels;
+		return children;
+	}
+	
+	public void setParent(CallTreeModel parent) {
+		this.parent = parent;
+	}
+	
+	public void addChildren(CallTreeModel child) {
+		this.children.add(child);
 	}
 }
diff --git a/src/org/ntlab/traceDebugger/CallTreeModels.java b/src/org/ntlab/traceDebugger/CallTreeModels.java
index 534c142..e9ba525 100644
--- a/src/org/ntlab/traceDebugger/CallTreeModels.java
+++ b/src/org/ntlab/traceDebugger/CallTreeModels.java
@@ -1,14 +1,18 @@
 package org.ntlab.traceDebugger;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
-
+import java.util.Map;
+import org.eclipse.core.resources.IMarker;
 import org.eclipse.jface.viewers.TreeNode;
 import org.ntlab.traceAnalysisPlatform.tracer.trace.MethodExecution;
+import org.ntlab.traceDebugger.analyzerProvider.DeltaMarkerManager;
 
 public class CallTreeModels {
 	private TreeNode[] roots;
 	private List<CallTreeModel> callTreeModelList = new ArrayList<>();
+	private Map<MethodExecution, CallTreeModel> callTreeModelsMemo = new HashMap<>();
 	
 	public TreeNode[] getCallTreeModels() {
 		return roots;
@@ -18,36 +22,108 @@
 		return callTreeModelList;
 	}
 	
-	public void update(MethodExecution from, MethodExecution to) {
-		reset();
-		createCallTreeModels(roots, 0, from, to);
-	}
-	
-	private boolean createCallTreeModels(TreeNode[] nodes, int index, MethodExecution me, final MethodExecution theLast) {
-		CallTreeModel callTreeModel = new CallTreeModel(me);
-		nodes[index] = new TreeNode(callTreeModel);
-		callTreeModelList.add(callTreeModel);
-		if (me.equals(theLast)) return true;
-		List<MethodExecution> children = me.getChildren();
-		TreeNode[] childNodes = new TreeNode[children.size()];
-		nodes[index].setChildren(childNodes);
-		for (int i = 0; i < children.size(); i++) {
-			MethodExecution child = children.get(i);
-			boolean isTheLast = createCallTreeModels(childNodes, i, child, theLast);
-			childNodes[i].setParent(nodes[index]);
-//			if (isTheLast) return true;
-			if (isTheLast) {
-				for (int j = i + 1; j < children.size(); j++) {
-					childNodes[j] = new TreeNode(null);
-				}
-				return true;
-			}
-		}
-		return false;
-	}
-	
 	public void reset() {
 		roots = new TreeNode[1];
 		callTreeModelList.clear();
+		callTreeModelsMemo.clear();
 	}
+	
+//	public void update(MethodExecution from, MethodExecution to) {
+//		reset();
+//		createCallTreeModels(roots, 0, from, to);
+//	}
+//	
+//	private boolean createCallTreeModels(TreeNode[] nodes, int index, MethodExecution me, final MethodExecution theLast) {
+//		CallTreeModel callTreeModel = new CallTreeModel(me);
+//		nodes[index] = new TreeNode(callTreeModel);
+//		callTreeModelList.add(callTreeModel);
+//		if (me.equals(theLast)) return true;
+//		List<MethodExecution> children = me.getChildren();
+//		TreeNode[] childNodes = new TreeNode[children.size()];
+//		nodes[index].setChildren(childNodes);
+//		for (int i = 0; i < children.size(); i++) {
+//			MethodExecution child = children.get(i);
+//			boolean isTheLast = createCallTreeModels(childNodes, i, child, theLast);
+//			childNodes[i].setParent(nodes[index]);
+////			if (isTheLast) return true;
+//			if (isTheLast) {
+//				for (int j = i + 1; j < children.size(); j++) {
+//					childNodes[j] = new TreeNode(null);
+//				}
+//				return true;
+//			}
+//		}
+//		return false;
+//	}
+	
+	public void update(DeltaMarkerManager deltaMarkerManager) {
+		reset();
+		IMarker coordinatorMarker = deltaMarkerManager.getCoordinatorDeltaMarker();
+		List<IMarker> srcSideMarkers = deltaMarkerManager.getMarkers().get(DeltaMarkerManager.SRC_SIDE_DELTA_MARKER);
+		List<IMarker> dstSideMarkers = deltaMarkerManager.getMarkers().get(DeltaMarkerManager.DST_SIDE_DELTA_MARKER);
+		IMarker bottomMarker = deltaMarkerManager.getBottomDeltaMarker();
+
+		MethodExecution coordinatorME = deltaMarkerManager.getMethodExecution(coordinatorMarker);
+		CallTreeModel coordinator = new CallTreeModel(coordinatorME);
+		callTreeModelsMemo.put(coordinatorME, coordinator);
+		for (IMarker srcSideMarker : srcSideMarkers) {
+			MethodExecution me = deltaMarkerManager.getMethodExecution(srcSideMarker);
+			CallTreeModel callTreeModel = new CallTreeModel(me);
+			if (!(callTreeModelsMemo.containsKey(me))) {
+				callTreeModelsMemo.put(me, callTreeModel);
+				create(callTreeModel, coordinatorME);
+			}
+		}
+		for (IMarker dstSideMarker : dstSideMarkers) {
+			MethodExecution me = deltaMarkerManager.getMethodExecution(dstSideMarker);
+			CallTreeModel callTreeModel = new CallTreeModel(me);
+			if (!(callTreeModelsMemo.containsKey(me))) {
+				callTreeModelsMemo.put(me, callTreeModel);
+				create(callTreeModel, coordinatorME);
+			}
+		}
+		MethodExecution bottomME = deltaMarkerManager.getMethodExecution(bottomMarker);
+		CallTreeModel bottom = new CallTreeModel(bottomME);
+		if (!(callTreeModelsMemo.containsKey(bottomME))) {
+			callTreeModelsMemo.put(bottomME, bottom);
+			create(bottom, coordinatorME);
+		}
+		createCallTreeModels(coordinator);
+	}
+	
+	private void create(CallTreeModel currentModel, final MethodExecution coordinatorME) {
+		MethodExecution currentME = currentModel.getMethodExecution();
+		MethodExecution parentME = currentME.getParent();
+		if (parentME == null) return;
+		CallTreeModel parentModel = callTreeModelsMemo.get(parentME);
+		boolean isNewParentModel = (parentModel == null);
+		if (isNewParentModel) {
+			parentModel = new CallTreeModel(parentME);
+			callTreeModelsMemo.put(parentME, parentModel);
+		}
+		currentModel.setParent(parentModel);
+		parentModel.addChildren(currentModel);
+		if (isNewParentModel && !(parentME.equals(coordinatorME))) {
+			create(parentModel, coordinatorME);
+		}
+	}
+	
+	private void createCallTreeModels(CallTreeModel coordinator) {
+		roots = new TreeNode[1];
+		callTreeModelList.clear();
+		create(roots, 0, coordinator, null);
+	}
+	
+	private void create(TreeNode[] nodes, int index, CallTreeModel callTreeModel, TreeNode parent) {
+		callTreeModelList.add(callTreeModel);
+		nodes[index] = new TreeNode(callTreeModel);
+		nodes[index].setParent(parent);
+		List<CallTreeModel> children = callTreeModel.getChildren();
+		TreeNode[] childNodes = new TreeNode[children.size()];
+		nodes[index].setChildren(childNodes);
+		for (int i = 0; i < childNodes.length; i++) {
+			CallTreeModel child = children.get(i);
+			create(childNodes, i, child, nodes[index]);
+		}
+	}	
 }
diff --git a/src/org/ntlab/traceDebugger/CallTreeView.java b/src/org/ntlab/traceDebugger/CallTreeView.java
index 54801ae..2470723 100644
--- a/src/org/ntlab/traceDebugger/CallTreeView.java
+++ b/src/org/ntlab/traceDebugger/CallTreeView.java
@@ -103,10 +103,16 @@
 		this.subId = subId;
 	}
 	
-	public void update(MethodExecution from, MethodExecution to) {
-		callTreeModels.update(from, to);
+//	public void update(MethodExecution from, MethodExecution to) {
+//		callTreeModels.update(from, to);
+//		viewer.setInput(callTreeModels.getCallTreeModels());
+//		viewer.expandAll();
+//	}
+	
+	public void update(DeltaMarkerManager deltaMarkerManager) {
+		callTreeModels.update(deltaMarkerManager);
 		viewer.setInput(callTreeModels.getCallTreeModels());
-		viewer.expandAll();
+		viewer.expandAll();		
 	}
 	
 	public void highlight(MethodExecution theMe) {
@@ -123,7 +129,10 @@
 	}
 	
 	public void reset() {
-		
+		callTreeModels.reset();
+//		callTreeModels.setInput();
+		viewer.setInput(callTreeModels.getCallTreeModelList());
+		viewer.refresh();
 	}
 	
 	private IViewPart getOtherView(String viewId, String subId) {
diff --git a/src/org/ntlab/traceDebugger/DeltaMarkerView.java b/src/org/ntlab/traceDebugger/DeltaMarkerView.java
index a7c5893..2951ee3 100644
--- a/src/org/ntlab/traceDebugger/DeltaMarkerView.java
+++ b/src/org/ntlab/traceDebugger/DeltaMarkerView.java
@@ -170,6 +170,8 @@
 	
 	public void dispose() {
 		deltaMarkerManager.clearAllMarkers();
+		CallTreeView callTreeView = ((CallTreeView)getOtherView(CallTreeView.ID, null));
+		callTreeView.reset();
 		super.dispose();
 	}
 	
diff --git a/src/org/ntlab/traceDebugger/VariableView.java b/src/org/ntlab/traceDebugger/VariableView.java
index 7def009..ab4bda0 100644
--- a/src/org/ntlab/traceDebugger/VariableView.java
+++ b/src/org/ntlab/traceDebugger/VariableView.java
@@ -168,8 +168,10 @@
 						CallStackView callStackView = (CallStackView)getOtherView(CallStackView.ID);
 						callStackView.highlight(coordinatorME);
 						CallTreeView callTreeView = (CallTreeView)getOtherView(CallTreeView.ID);
-						callTreeView.setSubId(subIdWithNewView);
-						callTreeView.update(coordinatorME, bottomME);
+//						callTreeView.setSubId(subIdWithNewView);
+//						callTreeView.update(coordinatorME, bottomME);
+//						callTreeView.highlight(coordinatorME);
+						callTreeView.update(deltaMarkerManager);
 						callTreeView.highlight(coordinatorME);
 					} catch (PartInitException e) {
 						e.printStackTrace();
diff --git a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java
index 71fe5ef..9a499e9 100644
--- a/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java
+++ b/src/org/ntlab/traceDebugger/analyzerProvider/DeltaMarkerManager.java
@@ -96,6 +96,24 @@
 		if (markers == null || markers.isEmpty()) return null;
 		return markers.get(0);
 	}
+	
+	public MethodExecution getMethodExecution(IMarker deltaMarker) {
+		try {
+			Object data = deltaMarker.getAttribute(DELTA_MARKER_ATR_DATA);
+			if (data instanceof MethodExecution) {
+				return (MethodExecution) data;
+			} else if (data instanceof TracePoint) {
+				TracePoint tp = (TracePoint)data;
+				return tp.getMethodExecution();
+			} else if (data instanceof Alias) {
+				Alias alias = (Alias)data;
+				return alias.getMethodExecution();
+			}
+		} catch (CoreException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
 
 	public void markAndOpenJavaFile(Alias alias, String message, String markerId) {
 		IFile file = JavaEditorOperator.findIFile(alias.getMethodExecution());