# HG changeset patch # User tatsuki # Date 1426558744 -32400 # Node ID 817febd9c69b15f512f2184c40ce249a6d8156e7 # Parent 169c501fe3a92bbaf887dd2eb324218b843d544d change transaction diff -r 169c501fe3a9 -r 817febd9c69b .idea/uiDesigner.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/.idea/uiDesigner.xml Tue Mar 17 11:19:04 2015 +0900 @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java --- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java Sun Mar 15 20:52:15 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungle.java Tue Mar 17 11:19:04 2015 +0900 @@ -9,13 +9,12 @@ import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeList; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Journal; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.NullJournal; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeContext; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor; 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.transaction.DefaultChangeSet; 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; @@ -78,12 +77,10 @@ } }; - DefaultTreeNode root = new DefaultTreeNode(); TreeMap>> indexList = TreeMap.empty(Ord.stringOrd); TreeMap parentIndex = new ParentIndex().getParentIndex(); - ChangeSet set = new DefaultChangeSet(root,null,list,uuid,name,0,indexList,parentIndex); - DefaultTreeContext tc = new DefaultTreeContext(root,set); + 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; diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java --- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java Sun Mar 15 20:52:15 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/DefaultJungleTree.java Tue Mar 17 11:19:04 2015 +0900 @@ -2,32 +2,30 @@ 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.ChangeSet; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeContext; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultJungleTreeEditor; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; 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.shoshi.jungle.util.GetOldTreeError; -import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; +import java.util.concurrent.atomic.AtomicReference; + public class DefaultJungleTree implements JungleTree { - private final AtomicReservableReference repository; + private final AtomicReference 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 AtomicReservableReference(tc); + this.repository = new AtomicReference(tc); this.uuid = uuid; this.writer = writer; this.treeEditor = editor; @@ -37,7 +35,7 @@ public JungleTreeEditor getTreeEditor() { TreeContext tc = repository.get(); DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid); - TreeNode root = tc.getTreeNode(); + TreeNode root = tc.getRoot(); return new DefaultJungleTreeEditor(root, txManager, treeEditor); } @@ -49,62 +47,53 @@ @Override public TreeNode getRootNode() { TreeContext tc = repository.get(); - ChangeSet cs = tc.getChangeSet(); - return cs.getRoot(); + return tc.getRoot(); } @Override public InterfaceTraverser getTraverser(boolean useIndex) { - AtomicReservableReference.Reservation reservation = repository.getReservation(); - IndexManager indexManager = new IndexManager(reservation); TreeMap>> index = getIndex(); ParentIndex parentIndex = getParentIndex(); - return new InterfaceTraverser(getRootNode(), index, parentIndex, indexManager, useIndex); + return new InterfaceTraverser(repository.get().getRoot(), index, parentIndex, useIndex); } @Override public ParentIndex getParentIndex() { TreeContext tc = repository.get(); - ChangeSet cs = tc.getChangeSet(); - return cs.getParentIndex(); + return tc.getParentIndex(); } @Override public TreeMap>> getIndex() { TreeContext tc = repository.get(); - ChangeSet cs = tc.getChangeSet(); - return cs.getIndex(); + return tc.getIndex(); } @Override public long revision() { TreeContext tc = repository.get(); - ChangeSet cs = tc.getChangeSet(); - return cs.revision(); + return tc.revision(); } @Override public Either getOldTree(long revision) { TreeContext tc = repository.get(); - ChangeSet cs = tc.getChangeSet(); - for (; cs.revision() != revision;) { - cs = cs.prev(); - if (cs == null) + for (; tc.revision() != revision;) { + tc = tc.prev(); + if (tc == null) return DefaultEither.newA(GetOldTreeError.OLD_TREE_NOT_FOUND); } - TreeNode root = cs.getRoot(); - TreeContext oldTc = new DefaultTreeContext(root, cs); String oldTreeUuid = uuid + revision; - JungleTree oldTree = new DefaultJungleTree(oldTc, oldTreeUuid, writer, treeEditor); + JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor); return DefaultEither.newB(oldTree); } @Override public Either getNodeOfPath(NodePath path) { - TreeNode node = repository.get().getTreeNode(); + TreeNode node = repository.get().getRoot(); for (int num : path) { if (num == -1) continue; diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java --- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/ChangeSet.java Sun Mar 15 20:52:15 2015 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,23 +0,0 @@ -package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store; - - - -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.tatsuki.jungle.store.index.ParentIndex; - -public interface ChangeSet -{ - public TreeNode getRoot(); - public ChangeSet prev(); - public ChangeList getChangeList(); - - public String uuid(); - public String getTreeName(); - public long revision(); - public TreeMap>> getIndex(); - public Iterable getOperations(); - public ParentIndex getParentIndex(); -} diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/store/TreeContext.java Tue Mar 17 11:19:04 2015 +0900 @@ -0,0 +1,25 @@ +package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store; + + + +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.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>> getIndex(); + public Iterable getOperations(); + public ParentIndex getParentIndex(); + public void setIndex(TreeMap>> index); + public void setParentIndex(ParentIndex parentIndex); +} diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java --- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java Sun Mar 15 20:52:15 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTransactionManager.java Tue Mar 17 11:19:04 2015 +0900 @@ -2,32 +2,30 @@ import java.util.Iterator; +import java.util.concurrent.atomic.AtomicReference; 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; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.Result; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; +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.impl.logger.TreeOperationLog; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.TreeOperation; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference.Reservation; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither; import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultError; 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.IndexManager; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class DefaultTransactionManager implements TransactionManager { - private final AtomicReservableReference repository; + private final AtomicReference repository; private final TreeContext tip; private final ChangeListWriter writer; private final String uuid; public DefaultTransactionManager(ChangeListWriter _writer, TreeContext _tip, - AtomicReservableReference _repository, String _uuid) { + AtomicReference _repository, String _uuid) { repository = _repository; tip = _tip; writer = _writer; @@ -35,12 +33,11 @@ } @Override - public Either commit(TreeNode _newRoot, final TreeOperationLog _log) { - ChangeSet cs = tip.getChangeSet(); - long currentRevision = cs.revision(); + public Either commit(TreeNode newRoot, final TreeOperationLog _log) { + long currentRevision = tip.revision(); long nextRevision = currentRevision + 1; - final String _treeName = cs.getTreeName(); + final String _treeName = tip.getTreeName(); ChangeList list = new ChangeList() { @Override public Iterator iterator() { @@ -58,26 +55,19 @@ } }; - IndexManager indexManager = new IndexManager(repository.getReservation()); - InterfaceTraverser traverser = new InterfaceTraverser(_newRoot, indexManager, true); - traverser.createIndex(); - TreeMap>> index = traverser.getIndex(); - ParentIndex parentIndex = traverser.getParentIndex(); - DefaultChangeSet newCs = new DefaultChangeSet(_newRoot, cs, list, uuid, _treeName, nextRevision, index, parentIndex.getParentIndex()); - DefaultTreeContext newContext = new DefaultTreeContext(_newRoot, newCs); + System.out.println("transaction"); + InterfaceTraverser traverser = new InterfaceTraverser(newRoot, true); + traverser.createIndex(); + TreeMap>> index = traverser.getIndex(); + ParentIndex parentIndex = traverser.getParentIndex(); + TreeContext newTreeContext = new DefaultTreeContext(newRoot , tip, list, uuid, _treeName, nextRevision,index,parentIndex.getParentIndex()); - @SuppressWarnings("rawtypes") - Reservation reservation = repository.makeReservation(tip, newContext); - if (reservation == null) { - return DefaultEither.newA((Error) new DefaultError()); + if (repository.compareAndSet(newTreeContext.prev(),newTreeContext)) { + TransactionManager txManager = new DefaultTransactionManager(writer, newTreeContext, repository, uuid); + return DefaultEither.newB(txManager); } - Result r = writer.write(list); - if (r == Result.SUCCESS) { - reservation.confirm(); - TransactionManager txManager = new DefaultTransactionManager(writer, newContext, repository, uuid); - return DefaultEither.newB(txManager); - } - return DefaultEither.newA((Error) new DefaultError()); + + return DefaultEither.newA((Error) new DefaultError()); } @Override @@ -87,7 +77,6 @@ @Override public long getRevision() { - ChangeSet cs = tip.getChangeSet(); - return cs.revision(); + return tip.revision(); } } diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java --- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java Sun Mar 15 20:52:15 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/transaction/DefaultTreeContext.java Tue Mar 17 11:19:04 2015 +0900 @@ -1,28 +1,98 @@ package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction; -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet; +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.tatsuki.jungle.store.index.ParentIndex; public class DefaultTreeContext implements TreeContext { private final TreeNode root; - private final ChangeSet cs; - - public DefaultTreeContext(TreeNode _newRoot,ChangeSet _cs) + private final TreeContext previous; + private final ChangeList changeList; + private final String uuid; + private final String treeName; + private final long revision; + private TreeMap>> indexList; + private TreeMap parentIndex; + + public DefaultTreeContext(TreeNode _node,TreeContext _prev,ChangeList _log,String _uuid, String _treeName, long _revision, TreeMap>> indexList, + TreeMap parentIndex) { - root = _newRoot; - cs = _cs; + this.root = _node; + this.previous = _prev; + this.changeList = _log; + this.uuid = _uuid; + this.treeName = _treeName; + this.revision = _revision; + this.indexList = indexList; + this.parentIndex = parentIndex; + } + + + @Override + public TreeNode getRoot() + { + return root; + } + + @Override + public TreeContext prev() + { + return previous; + } + + @Override + public ChangeList getChangeList() + { + return changeList; } @Override - public ChangeSet getChangeSet() + public String uuid() + { + return uuid; + } + + @Override + public String getTreeName() { - return cs; + return treeName; + } + + @Override + public long revision() + { + return revision; } @Override - public TreeNode getTreeNode() + public Iterable getOperations() { - return root; + return changeList; + } + + @Override + public TreeMap>> getIndex() { + return indexList; } + + + @Override + public ParentIndex getParentIndex() { + return new ParentIndex(parentIndex); + } + + @Override + public void setIndex(TreeMap>> indexList) { + this.indexList = indexList; + } + + @Override + public void setParentIndex(ParentIndex parentIndex) { + this.parentIndex = parentIndex.getParentIndex(); + } + } diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java --- a/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java Sun Mar 15 20:52:15 2015 +0900 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java Tue Mar 17 11:19:04 2015 +0900 @@ -4,35 +4,32 @@ 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; +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.tatsuki.jungle.query.PathNodeIterator; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.Query; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexCreater; -import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager; import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; public class InterfaceTraverser { - TreeNode node; + TreeNode root; TreeMap>> indexList; ParentIndex parentIndex; boolean parentUpdateFlag; - IndexManager indexManager; boolean useIndex; - public InterfaceTraverser(TreeNode root, IndexManager indexManager, boolean indexFlag) { - this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexManager, indexFlag); + public InterfaceTraverser(TreeNode root, boolean indexFlag) { + this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexFlag); } public InterfaceTraverser(TreeNode root, TreeMap>> index, - ParentIndex parentIndex, IndexManager indexManager, boolean useIndex) { - this.node = root; + ParentIndex parentIndex, boolean useIndex) { + this.root = root; this.indexList = index; - this.indexManager = indexManager; this.parentIndex = parentIndex; if (parentIndex.isEmpty()) parentUpdateFlag = true; @@ -47,7 +44,6 @@ public void commit() { parentUpdateFlag = false; - indexManager.commit(indexList, parentIndex); } public ParentIndex getParentIndex() { @@ -60,7 +56,7 @@ public void createIndex() { // long t1 = System.currentTimeMillis(); - IndexCreater creater = new IndexCreater(node); + IndexCreater creater = new IndexCreater(root); // long t2 = System.currentTimeMillis(); // System.out.println("createIndex time = " + (t2 - t1)); indexList = creater.getIndex(); @@ -141,12 +137,6 @@ /** * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する - * - * @param query - * @param subTree - * @param key - * @param searchValue - * @return */ // public Iterator findInSubTreeAllValue(final Query query, TreeNode // subTree, String key) { @@ -217,7 +207,7 @@ return nodeIterator; } else { - final PathNodeIterator itNode = new PathNodeIterator(node); + final PathNodeIterator itNode = new PathNodeIterator(root); return new Iterator() { private TreeNode matchNode = nextmatch(itNode); diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/CompareNode.java --- a/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/CompareNode.java Sun Mar 15 20:52:15 2015 +0900 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,29 +0,0 @@ -/*package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; - -import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; -import fj.data.HashMap; -import fj.data.List; - -public class CompareNode { - public List compare(JungleTree tree1, JungleTree tree2){ - List pNodes1 = traverser.traverse(tree1); - List pNodes2 = traverser.traverse(tree2); - HashMap map = new HashMap(null, null); - List muchNodes = new List(null); - for(PathNode pathNode : pNodes1){ - Either either = get(pathNode.getNode()); - if(either.isA()) - continue; - map.put(either.B(),pathNode); - } - for(PathNode pathNode : pNodes2){ - Either either = get(pathNode.getNode()); - if(either.isA()) - continue; - if(!map.containskey(either.B())) - continue; - muchNodes.add(tree1,pathNode.getPath(),pathNode.getNode(),tree2,map.get(either.B().getPath()),map.get(either.B().getNode())); - } - return muchNodes; - } -}*/ diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapBenchMark.java Tue Mar 17 11:19:04 2015 +0900 @@ -0,0 +1,56 @@ +package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; + +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor; +import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser; +import org.xml.sax.SAXException; + +import javax.xml.parsers.ParserConfigurationException; +import java.io.*; +import java.nio.ByteBuffer; + +/** + * Created by e115731 on 15/03/17. + */ +public class TreeMapBenchMark { + public static void main(String[] args) throws InterruptedException, IOException, ParserConfigurationException, SAXException { + System.out.println("startReadTree"); + + System.out.println("util"); + Runtime rt = Runtime.getRuntime(); + int cpuNum = rt.availableProcessors(); + + File file = new File("./readTreeMapTime"); + PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file))); + for (int THREAD_COUNT = 1; THREAD_COUNT <= cpuNum; THREAD_COUNT++) { + TreeMapReadThread readThread[] = new TreeMapReadThread[THREAD_COUNT]; + ; + for (int count = 0; THREAD_COUNT > count; count++) { + readThread[count] = new TreeMapReadThread(); + } + + for (int count = 0; THREAD_COUNT > count; count++) { + readThread[count].start(); + } + + System.out.println("StartThread"); + + Thread.sleep(1000); + long readCount = 0; + + for (int count = 0; THREAD_COUNT > count; count++) { + readCount = readCount + readThread[count].getFindCount(); + readThread[count].set(false); + } + + pw.println(THREAD_COUNT + " " + readCount); + System.out.println(THREAD_COUNT + "readCount = " + readCount); + } + + pw.close(); + } + +} diff -r 169c501fe3a9 -r 817febd9c69b src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapReadThread.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/main/java/jp/ac/u_ryukyu/ie/cr/tatsuki/jungle/test/TreeMapReadThread.java Tue Mar 17 11:19:04 2015 +0900 @@ -0,0 +1,45 @@ +package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.test; + +import fj.Ord; +import fj.data.Option; +import fj.data.TreeMap; + +/** + * Created by e115731 on 15/03/17. + */ +public class TreeMapReadThread extends Thread { + + //TreeMap map = TreeMap.empty(Ord.stringOrd); + java.util.TreeMap map = new java.util.TreeMap(); + private long findCount; + + boolean loop = true; + + public TreeMapReadThread() { + + //map = map.set("test","test"); + map.put("test","test"); + } + + public long getFindCount() { + System.out.println("thread count = " + findCount); + return findCount; + } + + public void set(boolean loop) { + this.loop = loop; + } + + @Override + public void run() { + while (loop) { + // Option op = map.get("test"); + // if (op.isSome()) + // findCount++; + if (map.get("test").equals("test")) + findCount++; + else + System.out.println("faild"); + } + } +}