X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.db.procore%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fprocore%2Fcluster%2FTestCluster.java;fp=bundles%2Forg.simantics.db.procore%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fprocore%2Fcluster%2FTestCluster.java;h=341af38ef78d8416a2c7c567c0a950225164a4f5;hp=0000000000000000000000000000000000000000;hb=969bd23cab98a79ca9101af33334000879fb60c5;hpb=866dba5cd5a3929bbeae85991796acb212338a08 diff --git a/bundles/org.simantics.db.procore/src/org/simantics/db/procore/cluster/TestCluster.java b/bundles/org.simantics.db.procore/src/org/simantics/db/procore/cluster/TestCluster.java new file mode 100644 index 000000000..341af38ef --- /dev/null +++ b/bundles/org.simantics.db.procore/src/org/simantics/db/procore/cluster/TestCluster.java @@ -0,0 +1,274 @@ +/******************************************************************************* + * Copyright (c) 2007, 2010 Association for Decentralized Information Management + * in Industry THTH ry. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * VTT Technical Research Centre of Finland - initial API and implementation + *******************************************************************************/ +package org.simantics.db.procore.cluster; + +import java.io.PrintStream; + +import org.simantics.db.Session; +import org.simantics.db.exception.DatabaseException; +import org.simantics.db.impl.ClusterBase; +import org.simantics.db.impl.ClusterI; +import org.simantics.db.impl.ClusterI.CompleteTypeEnum; +import org.simantics.db.impl.ClusterTranslator; +import org.simantics.db.service.ClusterUID; + +import fi.vtt.simantics.procore.internal.SessionImplSocket; +import gnu.trove.map.hash.TIntIntHashMap; + +final public class TestCluster { + private static final boolean DEBUG = false; + private static final int AddedResources = 100; //ClusterTraits.getMaxNumberOfResources(); + private static final int AddedStatements = 100; // Must be less than or equal to number of resources. + private static final int ValueCapacity = 5; + private final ClusterBase builtinCluster; + private final ClusterUID BuiltinClusterUID = ClusterUID.Builtin; + private final int BuiltinClusterKey; + private final ClusterBase foreignCluster; + private final ClusterUID ForeignClusterUID = ClusterUID.make(/*ClusterUID.Builtin.first*/0, ClusterUID.Builtin.second+1); + private final ClusterBase objectCluster; + private final ClusterUID ObjectClusterUID = ClusterUID.make(/*ClusterUID.Builtin.first*/0, ClusterUID.Builtin.second+2); + private final ClusterTranslator support; + PrintStream out = System.out; + TestCluster(Session session) { + support = ((SessionImplSocket)session).clusterTranslator; + builtinCluster = support.getClusterByClusterUIDOrMake(BuiltinClusterUID); + BuiltinClusterKey = builtinCluster.getClusterKey(); + foreignCluster = support.getClusterByClusterUIDOrMake(ForeignClusterUID); + objectCluster = support.getClusterByClusterUIDOrMake(ObjectClusterUID); + } + private void testReading(ClusterI cluster, int[] resourceKeys, int[] statementKeys, int[] objectKeys, boolean onePredicateOn, int AddedStatements, boolean foreignClusterOn) + throws DatabaseException { + Stopwatch sw = new Stopwatch(); + sw.start(); + for (int i = 0; i < AddedResources; ++i) { + int resourceKey = resourceKeys[i]; + CompleteTypeEnum ct = cluster.getCompleteType(resourceKey, support); + if (ct != CompleteTypeEnum.NotComplete) { + int ck = cluster.getCompleteObjectKey(resourceKey, support); + Assert(0 != ck); + Assert(objectKeys[0] == ck); + } + final TIntIntHashMap predicates = new TIntIntHashMap(); + final TIntIntHashMap countMap = new TIntIntHashMap(); + countMap.clear(); + ClusterI.ObjectProcedure readObjects = new ClusterI.ObjectProcedure() { + @Override + public boolean execute(final TIntIntHashMap objects, final int object) { + int i = objects.get(object); + objects.put(object, ++i); + return false; // continue looping + } + }; + ClusterI.PredicateProcedure readPredicates = new ClusterI.PredicateProcedure() { + @Override + public boolean execute(TIntIntHashMap set, int predicateKey, int objectIndex) { + set.put(predicateKey, objectIndex); + int i = countMap.get(predicateKey); + countMap.put(predicateKey, ++i); + return false; // continue looping + } + }; + cluster.forPredicates(resourceKey, readPredicates, predicates, support); + if (onePredicateOn) + Assert(predicates.size() == 1); + else { + Assert(predicates.size() == AddedStatements); + //Assert(cluster.isComplete(fyi, resourceKey, support)); + //Assert(cluster.getCompleteType(fyi, resourceKey, support) == ClusterI.CompleteTypeEnum.InstanceOf); + } + for (int j = 0; j < AddedStatements; ++j) { + int pKey = onePredicateOn ? resourceKey : statementKeys[j]; + if (onePredicateOn && foreignClusterOn) + pKey = statementKeys[0]; + Assert(predicates.contains(pKey)); + Assert(countMap.get(pKey) == 1); + int oIndex = predicates.get(pKey); + if (AddedStatements < 3) + Assert(oIndex == 0); + TIntIntHashMap objects = new TIntIntHashMap(); + TIntIntHashMap objects2 = new TIntIntHashMap(); + cluster.forObjects(resourceKey, pKey, oIndex, readObjects, objects, support); + cluster.forObjects(resourceKey, pKey, readObjects, objects2, support); + Assert(objects.size() == objects2.size()); + if (onePredicateOn) { + Assert(objects.size() == AddedStatements); + for (int k = 0; k < AddedStatements; ++k) { + int oKey = objectKeys[k]; + Assert(objects.contains(oKey)); + Assert(1 == objects.get(oKey)); + Assert(objects2.contains(oKey)); + Assert(1 == objects2.get(oKey)); + } + } else { + Assert(objects.size() == 1); + int oKey = objectKeys[j]; + Assert(objects.contains(oKey)); + Assert(1 == objects.get(oKey)); + Assert(objects2.contains(oKey)); + Assert(1 == objects2.get(oKey)); + } + } + if (!cluster.hasValue(resourceKey, support)) + throw new RuntimeException("hasValue() failed for resource key=" + resourceKey); + byte[] data = cluster.getValue(resourceKey, support); + Assert(data.length == ValueCapacity); + for (int l = 0; l < ValueCapacity; ++l) + Assert((byte) l == data[l]); + } + sw.stop(); + out.println("Elapsed time in millseconds " + sw.elapsedMilli() + " for reading."); + // cluster.check(); + // cluster.printDebugInfo(-1, "koss: ", support); + out.println("Used space consumption in bytes: " + cluster.getUsedSpace()); + + } + private int getResourceKey(int clusterKey, int resourceIndex) + throws DatabaseException { + return ClusterTraits.createResourceKey(clusterKey, resourceIndex); + } + private boolean clusterTest(boolean onePredicateOn, boolean foreignClusterOn, int AddedStatements) + throws DatabaseException { + String testName = "Cluster "; + out.println("********************************************"); + String eo = onePredicateOn ? "on" : "off"; + String fco = foreignClusterOn ? "on" : "off"; + out.println(testName + " test with one predicate " + eo + ", foreign cluster " + fco); + + Stopwatch sw = new Stopwatch(); + sw.start(); + + ClusterI cluster = ClusterImpl.make(BuiltinClusterUID, BuiltinClusterKey, support); + if (DEBUG) + System.out.println("cluster key=" + cluster.getClusterKey() + " id=" + cluster.getClusterId() + " uid=" + cluster.getClusterUID()); + byte[] value = new byte[ValueCapacity]; + for (int i = 0; i < ValueCapacity; ++i) + value[i] = (byte) i; + + Assert(AddedResources <= ClusterTraits.getMaxNumberOfResources()); + int[] resourceKeys = new int[AddedResources]; + for (int i = 0; i < AddedResources; ++i) { + resourceKeys[i] = cluster.createResource(support); + Assert(ClusterTraits.getResourceIndexFromResourceKey(resourceKeys[i]) == i + 1); + Assert(!cluster.isComplete(resourceKeys[i], support)); + } + int[] statementKeys = new int[AddedStatements]; + int[] objectKeys = new int[AddedStatements]; + for (int i = 0; i < AddedStatements; ++i) { + if (foreignClusterOn) { + Assert(AddedStatements <= ClusterTraits.getMaxNumberOfResources()); + statementKeys[i] = getResourceKey(foreignCluster.getClusterKey(), i + 1); + } else { + Assert(AddedStatements <= AddedResources); + statementKeys[i] = getResourceKey(builtinCluster.getClusterKey(), i + 1); + } + objectKeys[i] = getResourceKey(objectCluster.getClusterKey(), i + 1); + } + for (int i = 0; i < AddedResources; ++i) { + final int resourceKey = resourceKeys[i]; + for (int j = 0; j < AddedStatements; ++j) { + int sKey = resourceKey; + int pKey = onePredicateOn ? resourceKey : statementKeys[j]; + if (onePredicateOn && foreignClusterOn) + pKey = statementKeys[0]; + int oKey = objectKeys[j]; + cluster = cluster.addRelation(sKey, pKey, oKey, support); + if (null == cluster) + throw new RuntimeException("AddRelation() failed."); + if (null != cluster.addRelation(sKey, pKey, oKey, support)) + throw new RuntimeException("AddRelation() failed."); + } + cluster = cluster.setValue(resourceKey, value, value.length, support); + if (!cluster.hasValue(resourceKey, support)) + throw new RuntimeException("AddRelation() failed."); + byte[] data = cluster.getValue(resourceKey, support); + Assert(data.length == value.length); + for (int l = 0; l < value.length; ++l) + Assert((byte) l == data[l]); + } + + sw.stop(); + out.println("Elapsed time in milliseconds " + sw.elapsedMilli() + " for adding " + AddedResources + " Resources with " + AddedStatements + " statements."); + + testReading(cluster, resourceKeys, statementKeys, objectKeys, onePredicateOn, AddedStatements, foreignClusterOn); + + if (!(cluster instanceof ClusterBig)) { + sw.restart(); + ClusterI big = ((ClusterImpl)cluster).toBig(support); + sw.stop(); + out.println("Elapsed time in milliseconds " + sw.elapsedMilli() + " for converting to big."); + testReading(big, resourceKeys, statementKeys, objectKeys, onePredicateOn, AddedStatements, foreignClusterOn); + } + + sw.restart(); + for (int i = 0; i < AddedResources; ++i) { + int resourceKey = resourceKeys[i]; + for (int j = 0; j < AddedStatements; ++j) { + int sKey = resourceKey; + int pKey = onePredicateOn ? resourceKey : statementKeys[j]; + if (onePredicateOn && foreignClusterOn) + pKey = statementKeys[0]; + int oKey = objectKeys[j]; + if (!cluster.removeRelation(sKey, pKey, oKey, support)) + throw new RuntimeException("RemoveRelation() failed."); + if (cluster.removeRelation(sKey, pKey, oKey, support)) + throw new RuntimeException("RemoveRelation() failed."); + cluster.denyRelation(sKey, pKey, oKey, support); + } + if (!cluster.removeValue(resourceKey, support)) + throw new RuntimeException("removeValue() failed."); + if (cluster.removeValue(resourceKey, support)) + throw new RuntimeException("removeValue() failed."); + } + sw.stop(); + out.println("Elapsed time in millseconds " + sw.elapsedMilli() + " for deleting."); + out.println("Used space consumption in bytes: " + cluster.getUsedSpace()); + return false; // ok + } + + private void testBasic() + throws DatabaseException { + final int N = AddedStatements; + support.setStreamOff(true); + try { + for (int i = N; i < N + 1; ++i) { + clusterTest(false, false, i); + clusterTest(false, true, i); + clusterTest(true, false, i); + clusterTest(true, true, i); + } + } finally { + support.setStreamOff(false); + } + } + + private void Assert(boolean condition) + throws DatabaseException { + if (condition) + return; + DatabaseException e = new DatabaseException("Test failed!"); + e.printStackTrace(out); + throw e; + } + public static void test(Session session) { + TestCluster tc = new TestCluster(session); + try { + System.out.println("Begin of tests."); + tc.testBasic(); + System.out.println("End of tests."); + } catch (Throwable t) { + throw new RuntimeException("Tests failed.", t); + } + } + public static void main(String[] args) { + test(null); + } +}