Mercurial > hg > Members > tatsuki > bench > jungle-core
changeset 183:066d9c5758dc
change TreeContext
line wrap: on
line diff
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java Mon Mar 23 15:44:28 2015 +0900 @@ -18,73 +18,71 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; -public class DefaultJungle implements Jungle -{ - private Journal journal; - private ConcurrentHashMap<String,JungleTree> trees; - private String uuid; - private TreeEditor editor; - public static void main(String args[]) - { - DefaultJungle j = new DefaultJungle(null,"hoge",new DefaultTreeEditor(new DefaultTraverser())); - JungleTree t = j.createNewTree("fuga"); - - JungleTreeEditor e1 = t.getTreeEditor(); - - DefaultNodePath root = new DefaultNodePath(); - - Either<Error,JungleTreeEditor> either = e1.addNewChildAt(root,0); - e1 = either.b(); - either = e1.addNewChildAt(root.add(0),0); - e1 = either.b(); - e1.success(); - } - - public DefaultJungle(Journal journal,String uuid,TreeEditor editor) - { - this.journal = new NullJournal(); - this.trees = new ConcurrentHashMap<String,JungleTree>(); - this.uuid = uuid; - this.editor = editor; - } +public class DefaultJungle implements Jungle { + private Journal journal; + private ConcurrentHashMap<String, JungleTree> trees; + private String uuid; + private TreeEditor editor; + + public static void main(String args[]) { + DefaultJungle j = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser())); + JungleTree t = j.createNewTree("fuga"); + + JungleTreeEditor e1 = t.getTreeEditor(); + + DefaultNodePath root = new DefaultNodePath(); + + Either<Error, JungleTreeEditor> either = e1.addNewChildAt(root, 0); + e1 = either.b(); + either = e1.addNewChildAt(root.add(0), 0); + e1 = either.b(); + e1.success(); + } + + public DefaultJungle(Journal journal, String uuid, TreeEditor editor) { + this.journal = new NullJournal(); + this.trees = new ConcurrentHashMap<String, JungleTree>(); + this.uuid = uuid; + this.editor = editor; + } - @Override - public JungleTree getTreeByName(String name) - { - return trees.get(name); - } + @Override + public JungleTree getTreeByName(String name) { + return trees.get(name); + } + + @Override + public JungleTree createNewTree(final String name) { + ChangeList list = new ChangeList() { + @Override + public Iterator<TreeOperation> iterator() { + List<TreeOperation> nil = List.nil(); + return nil.iterator(); + } - @Override - public JungleTree createNewTree(final String name) - { - ChangeList list = new ChangeList(){ - @Override - public Iterator<TreeOperation> iterator() { - List<TreeOperation> nil = List.nil(); - return nil.iterator(); - } - @Override - public String uuid() { - return uuid; - } - @Override - public String getTreeName() { - return name; - } - - }; - DefaultTreeNode root = new DefaultTreeNode(); - TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd); - TreeMap<TreeNode, TreeNode> parentIndex = new ParentIndex().getParentIndex(); - TreeContext tc = new DefaultTreeContext(root,null,list,uuid,name,0,indexList,parentIndex); - JungleTree newTree = new DefaultJungleTree(tc,uuid,journal.getWriter(),editor); - if(trees.putIfAbsent(name,newTree) != null){ - return null; - } - return newTree; - } + @Override + public String uuid() { + return uuid; + } + + @Override + public String getTreeName() { + return name; + } + + }; + DefaultTreeNode root = new DefaultTreeNode(); + InterfaceTraverser traverser = new InterfaceTraverser(root, true); + TreeContext tc = new DefaultTreeContext(root, null, list, uuid, name, 0, traverser); + JungleTree newTree = new DefaultJungleTree(tc, uuid, journal.getWriter(), editor); + if (trees.putIfAbsent(name, newTree) != null) { + return null; + } + return newTree; + } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java Mon Mar 23 15:44:28 2015 +0900 @@ -1,5 +1,6 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle; +import fj.data.List; import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; @@ -19,90 +20,89 @@ public class DefaultJungleTree implements JungleTree { - private final AtomicReference<TreeContext> repository; - private final String uuid; - private final ChangeListWriter writer; - private final TreeEditor treeEditor; - - public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor) { - this.repository = new AtomicReference<TreeContext>(tc); - this.uuid = uuid; - this.writer = writer; - this.treeEditor = editor; - } + private final AtomicReference<TreeContext> repository; + private final String uuid; + private final ChangeListWriter writer; + private final TreeEditor treeEditor; - @Override - public JungleTreeEditor getTreeEditor() { - TreeContext tc = repository.get(); - DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid); - TreeNode root = tc.getRoot(); - return new DefaultJungleTreeEditor(root, txManager, treeEditor); - } + public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor) { + this.repository = new AtomicReference<TreeContext>(tc); + this.uuid = uuid; + this.writer = writer; + this.treeEditor = editor; + } - @Override - public JungleTreeEditor getLocalTreeEditor() { - return getTreeEditor(); - } - - @Override - public TreeNode getRootNode() { - TreeContext tc = repository.get(); - return tc.getRoot(); - } + @Override + public JungleTreeEditor getTreeEditor() { + TreeContext tc = repository.get(); + DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid); + TreeNode root = tc.getRoot(); + return new DefaultJungleTreeEditor(root, txManager, treeEditor); + } - @Override - public InterfaceTraverser getTraverser(boolean useIndex) { - TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index = getIndex(); - ParentIndex parentIndex = getParentIndex(); - return new InterfaceTraverser(repository.get().getRoot(), index, parentIndex, useIndex); - } + @Override + public JungleTreeEditor getLocalTreeEditor() { + return getTreeEditor(); + } - @Override - public ParentIndex getParentIndex() { - TreeContext tc = repository.get(); - return tc.getParentIndex(); - } + @Override + public TreeNode getRootNode() { + TreeContext tc = repository.get(); + return tc.getRoot(); + } - @Override - public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() { - TreeContext tc = repository.get(); - return tc.getIndex(); - } + @Override + public InterfaceTraverser getTraverser(boolean useIndex) { + TreeContext tc = repository.get(); + return tc.getTraverser(); + } - @Override - public long revision() { - TreeContext tc = repository.get(); - return tc.revision(); - } - - @Override - public Either<Error, JungleTree> getOldTree(long revision) { - TreeContext tc = repository.get(); - - for (; tc.revision() != revision;) { - tc = tc.prev(); - if (tc == null) - return DefaultEither.newA(GetOldTreeError.OLD_TREE_NOT_FOUND); + @Override + public ParentIndex getParentIndex() { + TreeContext tc = repository.get(); + return tc.getParentIndex(); } + @Override + public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + TreeContext tc = repository.get(); + return tc.getIndex(); + } - String oldTreeUuid = uuid + revision; - JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor); - return DefaultEither.newB(oldTree); - } + @Override + public long revision() { + TreeContext tc = repository.get(); + return tc.revision(); + } + + @Override + public Either<Error, JungleTree> getOldTree(long revision) { + TreeContext tc = repository.get(); - @Override - public Either<Error, TreeNode> getNodeOfPath(NodePath path) { - TreeNode node = repository.get().getRoot(); - for (int num : path) { - if (num == -1) - continue; - Either<Error, TreeNode> either = node.getChildren().at(num); - if (either.isA()) - return either; - node = either.b(); + for (; tc.revision() != revision; ) { + tc = tc.prev(); + if (tc == null) + return DefaultEither.newA(GetOldTreeError.OLD_TREE_NOT_FOUND); + } + + + String oldTreeUuid = uuid + revision; + JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor); + return DefaultEither.newB(oldTree); } - return DefaultEither.newB(node); - } + + @Override + public Either<Error, TreeNode> getNodeOfPath(NodePath path) { + TreeNode node = repository.get().getRoot(); + for (int num : path) { + if (num == -1) + continue; + Either<Error, TreeNode> either = node.getChildren().at(num); + if (either.isA()) + return either; + node = either.b(); + } + return DefaultEither.newB(node); + } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/JungleTree.java Mon Mar 23 15:44:28 2015 +0900 @@ -1,7 +1,7 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle; - +import fj.data.List; import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; @@ -10,15 +10,22 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; -public interface JungleTree -{ - public JungleTreeEditor getTreeEditor(); - public JungleTreeEditor getLocalTreeEditor(); +public interface JungleTree { + public JungleTreeEditor getTreeEditor(); + + public JungleTreeEditor getLocalTreeEditor(); + public TreeNode getRootNode(); - public long revision(); - public Either<Error, JungleTree> getOldTree(long revision); - public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex(); - public ParentIndex getParentIndex(); - public InterfaceTraverser getTraverser(boolean useIndex); - public Either<Error, TreeNode> getNodeOfPath(NodePath path); + + public long revision(); + + public Either<Error, JungleTree> getOldTree(long revision); + + public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex(); + + public ParentIndex getParentIndex(); + + public InterfaceTraverser getTraverser(boolean useIndex); + + public Either<Error, TreeNode> getNodeOfPath(NodePath path); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java Mon Mar 23 15:44:28 2015 +0900 @@ -1,25 +1,32 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store; - +import fj.data.List; import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; -public interface TreeContext -{ - public TreeNode getRoot(); - public TreeContext prev(); - public ChangeList getChangeList(); - - public String uuid(); - public String getTreeName(); - public long revision(); - public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex(); - public Iterable<TreeOperation> getOperations(); +public interface TreeContext { + public TreeNode getRoot(); + + public TreeContext prev(); + + public ChangeList getChangeList(); + + public String uuid(); + + public String getTreeName(); + + public long revision(); + + public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex(); + + public Iterable<TreeOperation> getOperations(); + public ParentIndex getParentIndex(); - public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index); - public void setParentIndex(ParentIndex parentIndex); + + public InterfaceTraverser getTraverser(); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java Mon Mar 23 15:44:28 2015 +0900 @@ -4,6 +4,7 @@ import java.util.Iterator; import java.util.concurrent.atomic.AtomicReference; +import fj.data.List; import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter; @@ -58,9 +59,7 @@ InterfaceTraverser traverser = new InterfaceTraverser(newRoot, true); traverser.createIndex(); - TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index = traverser.getIndex(); - ParentIndex parentIndex = traverser.getParentIndex(); - TreeContext newTreeContext = new DefaultTreeContext(newRoot , tip, list, uuid, _treeName, nextRevision,index,parentIndex.getParentIndex()); + TreeContext newTreeContext = new DefaultTreeContext(newRoot , tip, list, uuid, _treeName, nextRevision,traverser); if (repository.compareAndSet(newTreeContext.prev(),newTreeContext)) { TransactionManager txManager = new DefaultTransactionManager(writer, newTreeContext, repository, uuid);
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java Mon Mar 23 15:44:28 2015 +0900 @@ -1,98 +1,81 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction; +import fj.data.List; import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeContext; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; -public class DefaultTreeContext implements TreeContext -{ - private final TreeNode root; - private final TreeContext previous; - private final ChangeList changeList; - private final String uuid; - private final String treeName; - private final long revision; - private TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList; - private TreeMap<TreeNode, TreeNode> parentIndex; +public class DefaultTreeContext implements TreeContext { + private final TreeNode root; + private final TreeContext previous; + private final ChangeList changeList; + private final String uuid; + private final String treeName; + private final long revision; + private final InterfaceTraverser traverser; - public DefaultTreeContext(TreeNode _node,TreeContext _prev,ChangeList _log,String _uuid, String _treeName, long _revision, TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList, - TreeMap<TreeNode, TreeNode> parentIndex) - { - this.root = _node; - this.previous = _prev; - this.changeList = _log; - this.uuid = _uuid; - this.treeName = _treeName; - this.revision = _revision; - this.indexList = indexList; - this.parentIndex = parentIndex; - } + public DefaultTreeContext(TreeNode _node, TreeContext _prev, ChangeList _log, String _uuid, String _treeName, long _revision, InterfaceTraverser traverser) { + this.root = _node; + this.previous = _prev; + this.changeList = _log; + this.uuid = _uuid; + this.treeName = _treeName; + this.revision = _revision; + this.traverser = traverser; + } @Override - public TreeNode getRoot() - { - return root; - } - - @Override - public TreeContext prev() - { - return previous; - } - - @Override - public ChangeList getChangeList() - { - return changeList; - } - - @Override - public String uuid() - { - return uuid; - } + public TreeNode getRoot() { + return root; + } - @Override - public String getTreeName() - { - return treeName; - } - - @Override - public long revision() - { - return revision; - } - - @Override - public Iterable<TreeOperation> getOperations() - { - return changeList; - } - - @Override - public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() { - return indexList; - } - - - @Override - public ParentIndex getParentIndex() { - return new ParentIndex(parentIndex); - } + @Override + public TreeContext prev() { + return previous; + } @Override - public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList) { - this.indexList = indexList; + public ChangeList getChangeList() { + return changeList; + } + + @Override + public String uuid() { + return uuid; + } + + @Override + public String getTreeName() { + return treeName; } @Override - public void setParentIndex(ParentIndex parentIndex) { - this.parentIndex = parentIndex.getParentIndex(); + public long revision() { + return revision; + } + + @Override + public Iterable<TreeOperation> getOperations() { + return changeList; } + @Override + public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + return traverser.getIndex(); + } + + @Override + public ParentIndex getParentIndex() { + return traverser.getParentIndex(); + } + + @Override + public InterfaceTraverser getTraverser() { + return traverser; + } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeNodeAttribute.java Mon Mar 23 15:44:28 2015 +0900 @@ -64,8 +64,8 @@ return null; } - Option<ByteBuffer> result = attrs.get(_key); - return result.isSome() ? result.some() : null; + ByteBuffer result = attrs.getLoop(_key); + return result; } @Override
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java Mon Mar 23 15:44:28 2015 +0900 @@ -4,6 +4,7 @@ import fj.Ord; import fj.P2; +import fj.data.List; import fj.data.Option; import fj.data.TreeMap; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator; @@ -16,327 +17,306 @@ public class InterfaceTraverser { - TreeNode root; - TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList; - ParentIndex parentIndex; - boolean parentUpdateFlag; - boolean useIndex; - - public InterfaceTraverser(TreeNode root, boolean indexFlag) { - this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexFlag); - } + TreeNode root; + TreeMap<String, TreeMap<String, List<TreeNode>>> indexList; + ParentIndex parentIndex; + boolean parentUpdateFlag; + boolean useIndex; - public InterfaceTraverser(TreeNode root, TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index, - ParentIndex parentIndex, boolean useIndex) { - this.root = root; - this.indexList = index; - this.parentIndex = parentIndex; - if (parentIndex.isEmpty()) - parentUpdateFlag = true; - else - parentUpdateFlag = false; - this.useIndex = useIndex; - } + public InterfaceTraverser(TreeNode root, boolean indexFlag) { + this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexFlag); + } - public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() { - return indexList; - } + public InterfaceTraverser(TreeNode root, TreeMap<String, TreeMap<String, List<TreeNode>>> index, + ParentIndex parentIndex, boolean useIndex) { + this.root = root; + this.indexList = index; + this.parentIndex = parentIndex; + if (parentIndex.isEmpty()) + parentUpdateFlag = true; + else + parentUpdateFlag = false; + this.useIndex = useIndex; + } - public void commit() { - parentUpdateFlag = false; - } - - public ParentIndex getParentIndex() { - return parentIndex; - } + public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + return indexList; + } - public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index) { - this.indexList = index; - } + public void commit() { + parentUpdateFlag = false; + } + + public ParentIndex getParentIndex() { + return parentIndex; + } - public void createIndex() { - // long t1 = System.currentTimeMillis(); - IndexCreater creater = new IndexCreater(root); - // long t2 = System.currentTimeMillis(); - // System.out.println("createIndex time = " + (t2 - t1)); - indexList = creater.getIndex(); - parentIndex = creater.getParentIndex(); - } + public void createIndex() { + // long t1 = System.currentTimeMillis(); + IndexCreater creater = new IndexCreater(root); + // long t2 = System.currentTimeMillis(); + // System.out.println("createIndex time = " + (t2 - t1)); + indexList = creater.getIndex(); + parentIndex = creater.getParentIndex(); + } - /** - * subTree以下のNodeに対してKey,Valueのペアでindexを使って探索を行う - * - * @param query - * @param subTree - * @param key - * @param searchValue - * @return - */ - // public Iterator<TreeNode> findInSubTree(final Query query, TreeNode - // subTree, String key, String searchValue) { - // /* - // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、 - // * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す - // */ - // Iterator<TreeNode> nodeIterator = index.get(key, searchValue); - // if (nodeIterator.hasNext() && useIndex) { - // - // // ここでNode以下にあるか調べる - // List<TreeNode> filteredList = List.nil(); - // - // for (;nodeIterator.hasNext();) { - // TreeNode targetNode = nodeIterator.next(); - // TreeNode parent = targetNode; - // while (parent != null) { - // parent = parentIndex.get(parent); - // if (parent.equals(subTree)) - // filteredList = filteredList.cons(targetNode); - // } - // } - // - // return filteredList.iterator(); - // - // } else { - // final PathNodeIterator itNode = new PathNodeIterator(subTree); - // return new Iterator<TreeNode>() { - // - // private TreeNode matchNode = nextmatch(itNode); - // - // private TreeNode nextmatch(PathNodeIterator itNode) { - // - // for (; itNode.hasNext();) { - // TreeNode targetNode = itNode.next(); - // if (query.condition(targetNode)) - // return targetNode; - // } - // return null; - // } - // - // @Override - // public boolean hasNext() { - // if (matchNode == null) { - // return false; - // } - // return true; - // } - // - // @Override - // public TreeNode next() { - // TreeNode currentNode = matchNode; - // matchNode = nextmatch(itNode); - // return currentNode; - // } - // - // @Override - // public void remove() { - // } - // - // }; - // } - // } + /** + * subTree以下のNodeに対してKey,Valueのペアでindexを使って探索を行う + * + * @param query + * @param subTree + * @param key + * @param searchValue + * @return + */ + // public Iterator<TreeNode> findInSubTree(final Query query, TreeNode + // subTree, String key, String searchValue) { + // /* + // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、 + // * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す + // */ + // Iterator<TreeNode> nodeIterator = index.get(key, searchValue); + // if (nodeIterator.hasNext() && useIndex) { + // + // // ここでNode以下にあるか調べる + // List<TreeNode> filteredList = List.nil(); + // + // for (;nodeIterator.hasNext();) { + // TreeNode targetNode = nodeIterator.next(); + // TreeNode parent = targetNode; + // while (parent != null) { + // parent = parentIndex.get(parent); + // if (parent.equals(subTree)) + // filteredList = filteredList.cons(targetNode); + // } + // } + // + // return filteredList.iterator(); + // + // } else { + // final PathNodeIterator itNode = new PathNodeIterator(subTree); + // return new Iterator<TreeNode>() { + // + // private TreeNode matchNode = nextmatch(itNode); + // + // private TreeNode nextmatch(PathNodeIterator itNode) { + // + // for (; itNode.hasNext();) { + // TreeNode targetNode = itNode.next(); + // if (query.condition(targetNode)) + // return targetNode; + // } + // return null; + // } + // + // @Override + // public boolean hasNext() { + // if (matchNode == null) { + // return false; + // } + // return true; + // } + // + // @Override + // public TreeNode next() { + // TreeNode currentNode = matchNode; + // matchNode = nextmatch(itNode); + // return currentNode; + // } + // + // @Override + // public void remove() { + // } + // + // }; + // } + // } - /** - * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する - */ - // public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode - // subTree, String key) { - // /* - // * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得 - // * そのKeyを保有するNodeとNodeのPathを取得する - // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、 - // * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す - // */ - // Iterator<TreeNode> NodeIterator = index.getAll(key); - // if (NodeIterator != null && useIndex) { - // List<TreeNode> filteredList = List.nil(); - // for (; NodeIterator.hasNext();) { - // TreeNode targetNode = NodeIterator.next(); - // TreeNode parent = targetNode; - // while (parent != null) { - // parent = parentIndex.get(parent); - // if (parent.equals(subTree)) - // filteredList = filteredList.cons(targetNode); - // } - // } - // return filteredList.iterator(); - // - // } else { - // - // final PathNodeIterator itNode = new PathNodeIterator(subTree); - // return new Iterator<TreeNode>() { - // - // private TreeNode matchPair = nextmatch(itNode); - // - // private TreeNode nextmatch(PathNodeIterator itNode) { - // - // for (; itNode.hasNext();) { - // TreeNode targetNode = itNode.next(); - // if (query.condition(targetNode)) - // return targetNode; - // } - // return null; - // } - // - // @Override - // public boolean hasNext() { - // if (matchPair == null) { - // return false; - // } - // return true; - // } - // - // @Override - // public TreeNode next() { - // TreeNode currentNode = matchPair; - // matchPair = nextmatch(itNode); - // return currentNode; - // } - // - // @Override - // public void remove() { - // } - // - // }; - // } - // } + /** + * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する + */ + // public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode + // subTree, String key) { + // /* + // * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得 + // * そのKeyを保有するNodeとNodeのPathを取得する + // * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、 + // * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す + // */ + // Iterator<TreeNode> NodeIterator = index.getAll(key); + // if (NodeIterator != null && useIndex) { + // List<TreeNode> filteredList = List.nil(); + // for (; NodeIterator.hasNext();) { + // TreeNode targetNode = NodeIterator.next(); + // TreeNode parent = targetNode; + // while (parent != null) { + // parent = parentIndex.get(parent); + // if (parent.equals(subTree)) + // filteredList = filteredList.cons(targetNode); + // } + // } + // return filteredList.iterator(); + // + // } else { + // + // final PathNodeIterator itNode = new PathNodeIterator(subTree); + // return new Iterator<TreeNode>() { + // + // private TreeNode matchPair = nextmatch(itNode); + // + // private TreeNode nextmatch(PathNodeIterator itNode) { + // + // for (; itNode.hasNext();) { + // TreeNode targetNode = itNode.next(); + // if (query.condition(targetNode)) + // return targetNode; + // } + // return null; + // } + // + // @Override + // public boolean hasNext() { + // if (matchPair == null) { + // return false; + // } + // return true; + // } + // + // @Override + // public TreeNode next() { + // TreeNode currentNode = matchPair; + // matchPair = nextmatch(itNode); + // return currentNode; + // } + // + // @Override + // public void remove() { + // } + // + // }; + // } + // } + public Iterator<TreeNode> find(final Query query, final String key, String searchValue) { - public Iterator<TreeNode> find(final Query query, final String key, String searchValue) { - - Iterator<TreeNode> nodeIterator = get(key, searchValue); - if (nodeIterator != null && useIndex) { - return nodeIterator; - } else { - - final PathNodeIterator itNode = new PathNodeIterator(root); - return new Iterator<TreeNode>() { - - private TreeNode matchNode = nextmatch(itNode); - - private TreeNode nextmatch(PathNodeIterator itNode) { + Iterator<TreeNode> nodeIterator = get(key, searchValue); + if (nodeIterator != null && useIndex) { + return nodeIterator; + } else { - for (; itNode.hasNext();) { - TreeNode targetNode = itNode.next(); - String value = targetNode.getAttributes().getString(key); - if (useIndex) { - if (value != null) - ; - // index = index.set(key, value, targetNode); - } - if (parentUpdateFlag) - ; - // parentIndex = parentIndex.set(targetNode); - if (query.condition(targetNode)) - return targetNode; - } - if (useIndex || parentUpdateFlag) - commit(); - return null; - } + final PathNodeIterator itNode = new PathNodeIterator(root); + return new Iterator<TreeNode>() { + + private TreeNode matchNode = nextmatch(itNode); + + private TreeNode nextmatch(PathNodeIterator itNode) { - @Override - public boolean hasNext() { - if (matchNode == null) { - return false; - } - return true; - } + for (; itNode.hasNext(); ) { + TreeNode targetNode = itNode.next(); + String value = targetNode.getAttributes().getString(key); + if (useIndex) { + if (value != null) + ; + // index = index.set(key, value, targetNode); + } + if (parentUpdateFlag) + ; + // parentIndex = parentIndex.set(targetNode); + if (query.condition(targetNode)) + return targetNode; + } + if (useIndex || parentUpdateFlag) + commit(); + return null; + } - @Override - public TreeNode next() { - TreeNode currentPair = matchNode; - matchNode = nextmatch(itNode); - return currentPair; - } + @Override + public boolean hasNext() { + if (matchNode == null) { + return false; + } + return true; + } - @Override - public void remove() { - } + @Override + public TreeNode next() { + TreeNode currentPair = matchNode; + matchNode = nextmatch(itNode); + return currentPair; + } - }; + @Override + public void remove() { + } + + }; + } } - } - // public Iterator<TreeNode> findAll(final Query query, final String key) { - // - // Iterator<TreeNode> nodeList = index.getAll(key); - // if (nodeList != null && useIndex) { - // - // return nodeList; - // - // } else { - // - // final PathNodeIterator itNode = new PathNodeIterator(node); - // return new Iterator<TreeNode>() { - // - // private TreeNode matchNode = nextmatch(itNode); - // - // private TreeNode nextmatch(PathNodeIterator itNode) { - // - // for (; itNode.hasNext();) { - // TreeNode targetNode = itNode.next(); - // String value = targetNode.getAttributes().getString(key); - // if (useIndex) { - // if (value != null) - // index = index.set(key, value, targetNode); - // } - // if (parentUpdateFlag); - // // parentIndex = parentIndex.set(targetNode); - // if (query.condition(targetNode)) - // return targetNode; - // } - // if (useIndex || parentUpdateFlag) - // commit(); - // return null; - // } - // - // @Override - // public boolean hasNext() { - // if (matchNode == null) { - // return false; - // } - // return true; - // } - // - // @Override - // public TreeNode next() { - // TreeNode currentPair = matchNode; - // matchNode = nextmatch(itNode); - // return currentPair; - // } - // - // @Override - // public void remove() { - // } - // - // }; - // } - // } - - public Iterator<TreeNode> get(String key, String value) { + // public Iterator<TreeNode> findAll(final Query query, final String key) { + // + // Iterator<TreeNode> nodeList = index.getAll(key); + // if (nodeList != null && useIndex) { + // + // return nodeList; + // + // } else { + // + // final PathNodeIterator itNode = new PathNodeIterator(node); + // return new Iterator<TreeNode>() { + // + // private TreeNode matchNode = nextmatch(itNode); + // + // private TreeNode nextmatch(PathNodeIterator itNode) { + // + // for (; itNode.hasNext();) { + // TreeNode targetNode = itNode.next(); + // String value = targetNode.getAttributes().getString(key); + // if (useIndex) { + // if (value != null) + // index = index.set(key, value, targetNode); + // } + // if (parentUpdateFlag); + // // parentIndex = parentIndex.set(targetNode); + // if (query.condition(targetNode)) + // return targetNode; + // } + // if (useIndex || parentUpdateFlag) + // commit(); + // return null; + // } + // + // @Override + // public boolean hasNext() { + // if (matchNode == null) { + // return false; + // } + // return true; + // } + // + // @Override + // public TreeNode next() { + // TreeNode currentPair = matchNode; + // matchNode = nextmatch(itNode); + // return currentPair; + // } + // + // @Override + // public void remove() { + // } + // + // }; + // } + // } - Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key); - if (indexOp.isNone()) - return null; + public Iterator<TreeNode> get(String key, String value) { - TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some(); - Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value); - - if (nodeMapOp.isNone()) - return new NulIterator<TreeNode>(); - - Iterator<P2<TreeNode, TreeNode>> mapIterator = nodeMapOp.some().iterator(); - return new Iterator<TreeNode>() { + TreeMap<String, List<TreeNode>> index = indexList.getLoop(key); + if (index == null) + return null; - @Override - public boolean hasNext() { - return mapIterator.hasNext(); - } - - @Override - public TreeNode next() { - return mapIterator.next()._1(); - } - - }; - } + List<TreeNode> nodeList = index.getLoop(value); + if (nodeList == null) + return new NulIterator<TreeNode>(); + return nodeList.iterator(); + } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/IndexCreater.java Mon Mar 23 15:44:28 2015 +0900 @@ -12,104 +12,102 @@ public class IndexCreater { - TreeNode root; - TreeNode node; - int childNumber; - private TreeNodeChildren children; - private Stack<TreeNode> nodeStack = new Stack<TreeNode>(); - private Stack<Integer> searchStack = new Stack<Integer>(); - ParentIndex parentIndex = new ParentIndex(); - TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd); + TreeNode root; + TreeNode node; + int childNumber; + private TreeNodeChildren children; + private Stack<TreeNode> nodeStack = new Stack<TreeNode>(); + private Stack<Integer> searchStack = new Stack<Integer>(); + ParentIndex parentIndex = new ParentIndex(); + TreeMap<String, TreeMap<String, List<TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd); - public IndexCreater(TreeNode rootNode) { - this.root = rootNode; - this.node = rootNode; - while (node != null) { - TreeNode targetNode = node; - List<String> keys = targetNode.getAttributes().getKeys(); - for (String key : keys) { - String value = targetNode.getAttributes().getString(key); - if (value != null) - indexList = set(key, value, targetNode); - } - if (node.getChildren().size() > 0) { - nodeStack.push(node); - TreeNode parent = node; - children = node.getChildren(); - node = children.at(0).b(); - parentIndex.set(parent, node); - childNumber = 1; - searchStack.push(childNumber); - } else if (node == root) { - node = null; // no more node - children = null; - return; - } else if (children != null && children.size() > childNumber) { - childNumber = searchStack.pop(); - TreeNode parent = nodeStack.pop(); - nodeStack.push(parent); - node = children.at(childNumber).b(); - parentIndex.set(parent, node); - searchStack.push(++childNumber); - } else { - node = nodeStack.pop(); - children = node.getChildren(); - childNumber = searchStack.pop(); - for (; children.size() == childNumber;) { - if (node == root) { - node = null; // no more node - children = null; - return; - } - node = nodeStack.pop(); - children = node.getChildren(); - childNumber = searchStack.pop(); + public IndexCreater(TreeNode rootNode) { + this.root = rootNode; + this.node = rootNode; + while (node != null) { + TreeNode targetNode = node; + List<String> keys = targetNode.getAttributes().getKeys(); + for (String key : keys) { + String value = targetNode.getAttributes().getString(key); + if (value != null) + indexList = set(key, value, targetNode); + } + if (node.getChildren().size() > 0) { + nodeStack.push(node); + TreeNode parent = node; + children = node.getChildren(); + node = children.at(0).b(); + parentIndex.set(parent, node); + childNumber = 1; + searchStack.push(childNumber); + } else if (node == root) { + node = null; // no more node + children = null; + return; + } else if (children != null && children.size() > childNumber) { + childNumber = searchStack.pop(); + TreeNode parent = nodeStack.pop(); + nodeStack.push(parent); + node = children.at(childNumber).b(); + parentIndex.set(parent, node); + searchStack.push(++childNumber); + } else { + node = nodeStack.pop(); + children = node.getChildren(); + childNumber = searchStack.pop(); + for (; children.size() == childNumber; ) { + if (node == root) { + node = null; // no more node + children = null; + return; + } + node = nodeStack.pop(); + children = node.getChildren(); + childNumber = searchStack.pop(); + } + if (node != null && childNumber < children.size()) { + nodeStack.push(node); + TreeNode parent = node; + node = children.at(childNumber).b(); + parentIndex.set(parent, node); + searchStack.push(++childNumber); + } + } } - if (node != null && childNumber < children.size()) { - nodeStack.push(node); - TreeNode parent = node; - node = children.at(childNumber).b(); - parentIndex.set(parent, node); - searchStack.push(++childNumber); - } - } - } - } - - public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> set(String key, String value, TreeNode node) { - - Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key); - if (indexOp.isNone()) { - TreeMap<String, TreeMap<TreeNode, TreeNode>> index = TreeMap.empty(Ord.stringOrd); - TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd); - nodeMap = nodeMap.set(node, node); - TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, nodeMap); - indexList = indexList.set(key, newIndex); - return indexList; } - TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some(); - Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value); + public TreeMap<String, TreeMap<String, List<TreeNode>>> set(String key, String value, TreeNode node) { + + TreeMap<String, List<TreeNode>> index = indexList.getLoop(key); + if (index == null) { + index = TreeMap.empty(Ord.stringOrd); + List<TreeNode> nodeList = List.nil(); + nodeList = nodeList.cons(node); + TreeMap<String, List<TreeNode>> newIndex = index.set(value, nodeList); + indexList = indexList.set(key, newIndex); + return indexList; + } - TreeMap<TreeNode, TreeNode> newNodeMap; - if (nodeMapOp.isSome()) { - TreeMap<TreeNode, TreeNode> nodeMap = nodeMapOp.some(); - newNodeMap = nodeMap.set(node, node); - } else { - TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd); - newNodeMap = nodeMap.set(node, node); + List<TreeNode> nodeList = index.getLoop(value); + + List<TreeNode> newNodeList; + if (nodeList != null) { + newNodeList = nodeList.cons(node); + } else { + nodeList = List.nil(); + newNodeList = nodeList.cons(node); + } + TreeMap<String, List<TreeNode>> newIndex = index.set(value, newNodeList); + indexList = indexList.set(key, newIndex); + + return indexList; } - TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, newNodeMap); - indexList = indexList.set(key, newIndex); - return indexList; - } + public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() { + return indexList; + } - public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() { - return indexList; - } - - public ParentIndex getParentIndex() { - return parentIndex; - } + public ParentIndex getParentIndex() { + return parentIndex; + } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/ParentIndex.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/store/index/ParentIndex.java Mon Mar 23 15:44:28 2015 +0900 @@ -33,9 +33,9 @@ } public TreeNode get(TreeNode child) { - Option<TreeNode> parentOp = parentIndex.get(child); - if (parentOp.isSome()) - return parentOp.some(); + TreeNode parent = parentIndex.getLoop(child); + if (parent != null) + return parent; return null; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJListAccessThread.java Mon Mar 23 15:44:28 2015 +0900 @@ -0,0 +1,42 @@ +package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; + + +import fj.data.List; +import fj.data.Option; + +import java.util.Iterator; + +/** + * Created by e115731 on 15/03/21. + */ +public class FJListAccessThread extends AbstractTreeMapThread { + Option<List<String>> list; + private long findCount; + boolean loop = true; + + public FJListAccessThread(Option<List<String>> list) { + this.list = list; + } + + @Override + public long getFindCount() { + System.out.println("thread count = " + findCount); + return findCount; + } + + @Override + public void set(boolean loop) { + this.loop = loop; + } + + @Override + public void run() { + while (loop) { + Iterator<String> it = list.some().iterator(); + for (; it.hasNext(); ) { + String str = it.next(); + } + findCount++; + } + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJTreeMapGetIteratorThread.java Mon Mar 23 15:44:28 2015 +0900 @@ -0,0 +1,44 @@ +package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; + + +import fj.P2; +import fj.data.Option; +import fj.data.TreeMap; + +import java.util.Iterator; + + +/** + * Created by e115731 on 15/03/17. + */ +public class FJTreeMapGetIteratorThread extends AbstractTreeMapThread { + TreeMap<String, String> map; + private long findCount; + boolean loop = true; + + public FJTreeMapGetIteratorThread(TreeMap map) { + this.map = map; + } + + @Override + public long getFindCount() { + System.out.println("thread count = " + findCount); + return findCount; + } + + @Override + public void set(boolean loop) { + this.loop = loop; + } + + @Override + public void run() { + while (loop) { + Iterator<P2<String, String>> it = map.iterator(); + for (; it.hasNext(); ) { + if (it.next()._2().equals("50")) + findCount++; + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FJTreeMapGetLoopThread.java Mon Mar 23 15:44:28 2015 +0900 @@ -0,0 +1,45 @@ +package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; + +import fj.P2; +import fj.data.Option; +import fj.data.TreeMap; + +import java.util.Iterator; + +/** + * Created by e115731 on 15/03/17. + */ +public class FJTreeMapGetLoopThread extends AbstractTreeMapThread { + + TreeMap<String, String> map; + private long findCount; + boolean loop = true; + + public FJTreeMapGetLoopThread(TreeMap map) { + this.map = map; + } + + @Override + public long getFindCount() { + System.out.println("thread count = " + findCount); + return findCount; + } + + @Override + public void set(boolean loop) { + this.loop = loop; + } + + @Override + public void run() { + while (loop) { + String op = map.getLoop("50"); + if (op != null) + findCount++; + else + System.out.println("faild"); + + + } + } +}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/FunctionalTreeMapReadThread.java Fri Mar 20 15:35:53 2015 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,40 +0,0 @@ -package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; - -import fj.data.Option; -import fj.data.TreeMap; - -/** - * Created by e115731 on 15/03/17. - */ -public class FunctionalTreeMapReadThread extends AbstractTreeMapThread{ - - TreeMap<String,String> map; - private long findCount; - boolean loop = true; - - public FunctionalTreeMapReadThread(TreeMap map) { - this.map = map; - } - - @Override - public long getFindCount() { - System.out.println("thread count = " + findCount); - return findCount; - } - - @Override - public void set(boolean loop) { - this.loop = loop; - } - - @Override - public void run() { - while (loop) { - Option<String> op = map.get("test"); - if (op.isSome()) - findCount++; - else - System.out.println("faild"); - } - } -}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/JungleBenchMark.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/JungleBenchMark.java Mon Mar 23 15:44:28 2015 +0900 @@ -24,25 +24,42 @@ public static void main(String[] args) throws InterruptedException, IOException, ParserConfigurationException, SAXException { - if (args.length == 0) { - System.out.println("args read or find"); + if (args.length < 1) { + System.out.println("args[0] = read or find, args[1] = separate or nonSeparate"); System.exit(0); } - Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser())); - JungleTree tree = jungle.createNewTree("Person"); - JungleTreeEditor editor = tree.getTreeEditor(); - JungleTreeEditor newEditor = createTree(0,new DefaultNodePath(),editor); - if (newEditor.success().isA()) { - System.out.println("success faild"); - System.exit(1); - } - Runtime rt = Runtime.getRuntime(); int cpuNum = rt.availableProcessors(); + Jungle jungle = new DefaultJungle(null, "hoge", new DefaultTreeEditor(new DefaultTraverser())); + JungleTree trees[] = new JungleTree[cpuNum]; - File file = new File("./time/JungleTree" + args[0] + "Time"); + if (args[1].equals("separate")){ + for (int count = 0; count < cpuNum; count++) { + JungleTree tree = jungle.createNewTree("tree" + count); + JungleTreeEditor editor = tree.getTreeEditor(); + editor = editor.putAttribute(new DefaultNodePath(), "key", ByteBuffer.wrap(String.valueOf(0).getBytes())).b(); + JungleTreeEditor newEditor = createTree(0, new DefaultNodePath(), editor); + if (newEditor.success().isA()) { + System.out.println("success faild"); + System.exit(1); + } + trees[count] = tree; + } + } else { + JungleTree tree = jungle.createNewTree("tree" ); + JungleTreeEditor editor = tree.getTreeEditor(); + editor = editor.putAttribute(new DefaultNodePath(), "key", ByteBuffer.wrap(String.valueOf(0).getBytes())).b(); + JungleTreeEditor newEditor = createTree(0, new DefaultNodePath(), editor); + if (newEditor.success().isA()) { + System.out.println("success faild"); + System.exit(1); + } + trees[0] = tree; + } + + File file = new File("./time/" + args[1] + "JungleTree" + args[0] + "Time"); PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file))); @@ -50,13 +67,21 @@ for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) { readThread = new JungleBenchMarkThread[THREAD_COUNT]; - + JungleTree tree = null; if (args[0].equals("read")) { for (int count = 0; THREAD_COUNT > count; count++) { + if (args[1].equals("separate")) + tree = trees[count]; + else + tree = trees[0]; readThread[count] = new readTreeAttributeThread(tree); } } else if (args[0].equals("find")) { for (int count = 0; THREAD_COUNT > count; count++) { + if (args[1].equals("separate")) + tree = trees[count]; + else + tree = trees[0]; readThread[count] = new findTreeAttributeThread(tree); } } else { @@ -76,26 +101,29 @@ for (int count = 0; THREAD_COUNT > count; count++) { readCount = readCount + readThread[count].getFindCount(); readThread[count].set(false); + readThread[count] = null; } pw.println(THREAD_COUNT + " " + readCount); System.out.println(THREAD_COUNT + "readCount = " + readCount); + System.gc(); + System.out.println("-------------GC--------------"); + Thread.sleep(1000); } pw.close(); } - static Integer nodeNum = 0; + static Integer nodeNum = 1; + public static JungleTreeEditor createTree(int deep, NodePath path, JungleTreeEditor editor) { Random rnd = new Random(); String value1 = String.valueOf(nodeNum); - nodeNum ++; + nodeNum++; String value2 = String.valueOf(nodeNum); - nodeNum ++; + nodeNum++; - if (value1.equals("500")) - System.out.println("aaa"); editor = editor.addNewChildAt(path, 0).b(); editor = editor.putAttribute(path.add(0), "key", ByteBuffer.wrap(value1.getBytes())).b(); editor = editor.addNewChildAt(path, 1).b();
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java Mon Mar 23 15:44:28 2015 +0900 @@ -1,6 +1,8 @@ package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; import fj.Ord; +import fj.data.List; +import fj.data.Option; import fj.data.TreeMap; import org.xml.sax.SAXException; @@ -15,35 +17,46 @@ if (args.length == 0) { - System.out.println("args fj or util"); + System.out.println("args get or getLoop or list"); System.exit(0); } Runtime rt = Runtime.getRuntime(); int cpuNum = rt.availableProcessors(); - File file = new File("./time//get" + args[0] + "TreeMapTime"); + File file = new File("./time/" + args[0] + "Time"); PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file))); AbstractTreeMapThread readThread[] = null; - for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) { + TreeMap<String, String> map = TreeMap.empty(Ord.stringOrd); + List<String> list = List.nil(); + if (args[0].equals("list")) { + for (int count = 0 ;count < 100 ; count++) { + list = list.cons(String.valueOf(count)); + } + } + for (int count = 0 ;count < 1000 ; count++) { + map = map.set(String.valueOf(count), String.valueOf(count)); + } + for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) { + readThread = new AbstractTreeMapThread[THREAD_COUNT]; - if (args[0].equals("fj")) { - TreeMap<String, String> map = TreeMap.empty(Ord.stringOrd); - map = map.set("test","'test"); + if (args[0].equals("getLoop")) { for (int count = 0; THREAD_COUNT > count; count++) { - readThread[count] = new FunctionalTreeMapReadThread(map); + readThread[count] = new FJTreeMapGetLoopThread(map); } - } else if (args[0].equals("util")) { - java.util.TreeMap map = new java.util.TreeMap(); - map.put("test","test"); + } else if (args[0].equals("get")) { for (int count = 0; THREAD_COUNT > count; count++) { - readThread[count] = new UtilTreeMapReadThread(map); + readThread[count] = new FJTreeMapGetIteratorThread(map); } - } else { + } else if (args[0].equals("list")) { + for (int count = 0; THREAD_COUNT > count; count++) { + readThread[count] = new FJListAccessThread(Option.<List<String>>some(list)); + } + } else{ System.out.println("not allow args"); System.exit(0); }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/UtilTreeMapReadThread.java Fri Mar 20 15:35:53 2015 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,40 +0,0 @@ -package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; - - -import java.util.TreeMap; - -/** - * Created by e115731 on 15/03/17. - */ -public class UtilTreeMapReadThread extends AbstractTreeMapThread { - - TreeMap map; - private long findCount; - - boolean loop = true; - - public UtilTreeMapReadThread(TreeMap map) { - this.map = map; - } - - @Override - public long getFindCount() { - System.out.println("thread count = " + findCount); - return findCount; - } - - @Override - public void set(boolean loop) { - this.loop = loop; - } - - @Override - public void run() { - while (loop) { - if (map.get("test").equals("test")) - findCount++; - else - System.out.println("faild"); - } - } -}
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/findTreeAttributeThread.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/findTreeAttributeThread.java Mon Mar 23 15:44:28 2015 +0900 @@ -12,14 +12,14 @@ public class findTreeAttributeThread extends JungleBenchMarkThread { JungleTree tree; - InterfaceTraverser traverser; + //InterfaceTraverser traverser; private long findCount; boolean loop = true; public findTreeAttributeThread(JungleTree tree) { this.tree = tree; - this.traverser = tree.getTraverser(false); + // this.traverser = tree.getTraverser(true); this.findCount = 0; } @@ -36,20 +36,13 @@ @Override public void run() { while (loop) { + InterfaceTraverser traverser = tree.getTraverser(false); + // Iterator<TreeNode> it = traverser.find((TreeNode node) -> {return true;}, "key", "0"); - Iterator<TreeNode> it = traverser.find((TreeNode node) -> { - String nodeNum = node.getAttributes().getString("key"); - if (nodeNum == null) - return false; - if (nodeNum.equals("8")) - return true; - return false; - }, "key","8"); - - if (it.hasNext()) - findCount++; - else - System.out.println("faild"); + // if (it.hasNext()) { + findCount++; + // } else + // System.out.println("faild"); } } }
--- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/readTreeAttributeThread.java Fri Mar 20 15:35:53 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/readTreeAttributeThread.java Mon Mar 23 15:44:28 2015 +0900 @@ -3,6 +3,8 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; +import java.nio.ByteBuffer; + /** * Created by e115731 on 15/03/17. */ @@ -20,7 +22,7 @@ @Override public long getFindCount() { - System.out.println("thread count = " + findCount); + System.out.println("thread couny = " + findCount); return findCount; } @@ -32,13 +34,13 @@ public void run() { while (loop) { TreeNode root = tree.getRootNode(); - if (root != null) - findCount++; - String attribute = root.getAttributes().getString("test"); - if (attribute.equals("test")) - findCount++; - else - System.out.println("faild"); + if (root != null) { + String attribute = root.getAttributes().getString("key"); + if (attribute.equals("0")) + findCount++; + else + System.out.println("faild"); + } } } }