From 4a008135d58a5045245d7f6aa36793c8ed32e4d5 Mon Sep 17 00:00:00 2001 From: Marko Luukkainen Date: Wed, 28 Feb 2018 13:14:29 +0200 Subject: [PATCH] Using bindings when comparing literal values (perf optimization) --- .../interop/test/GraphComparator.java | 80 ++++- .../interop/test/TypeComparator.java | 329 +++++++++--------- 2 files changed, 239 insertions(+), 170 deletions(-) diff --git a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java index 11b3d1a..f5c4dfc 100644 --- a/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java +++ b/org.simantics.interop/src/org/simantics/interop/test/GraphComparator.java @@ -24,6 +24,7 @@ import java.util.Map.Entry; import java.util.Set; import java.util.Stack; +import org.simantics.databoard.Bindings; import org.simantics.db.ReadGraph; import org.simantics.db.Resource; import org.simantics.db.Session; @@ -769,9 +770,6 @@ public class GraphComparator { } else { if (DEBUG) System.out.println(left + " = " + right); comparableResources.map(left, right); - //if (left.getResourceId() == 313071 && right.getResourceId() == 325324) - if (left.getResourceId() == 313231 && right.getResourceId() == 337775) - System.out.println(); } } @@ -1191,9 +1189,10 @@ public class GraphComparator { boolean b2 = g.hasValue(s2.getObject()); if (b1 == b2) { if (b1) { - Object v1 = g.getValue(s1.getObject()); - Object v2 = g.getValue(s2.getObject()); - boolean eq = compareValue(v1, v2); +// Object v1 = g.getValue(s1.getObject()); +// Object v2 = g.getValue(s2.getObject()); +// boolean eq = compareValue(v1, v2); + boolean eq = compareValue(g,b,s1.getObject(), s2.getObject()); if (!eq) { addModification(s1, s2); addComparable(s1, s2); @@ -1232,6 +1231,75 @@ public class GraphComparator { } + public static boolean compareValue(ReadGraph g, Layer0 b, Resource r1, Resource r2) throws DatabaseException { + Resource t1 = g.getSingleType(r1); + Resource t2 = g.getSingleType(r2); + if (!t1.equals(t2)) + return false; + if (t1.equals(b.Integer)) { + int v1 = g.getValue(r1, Bindings.INTEGER); + int v2 = g.getValue(r2, Bindings.INTEGER); + return v1 == v2; + } else if (t1.equals(b.Float)) { + float v1 = g.getValue(r1, Bindings.FLOAT); + float v2 = g.getValue(r2, Bindings.FLOAT); + return v1 == v2; + } else if (t1.equals(b.Double)) { + double v1 = g.getValue(r1, Bindings.DOUBLE); + double v2 = g.getValue(r2, Bindings.DOUBLE); + return v1 == v2; + } else if (t1.equals(b.String)) { + String v1 = g.getValue(r1, Bindings.STRING); + String v2 = g.getValue(r2, Bindings.STRING); + return v1.equals(v2); + } else if (t1.equals(b.Boolean)) { + boolean v1 = g.getValue(r1, Bindings.BOOLEAN); + boolean v2 = g.getValue(r2, Bindings.BOOLEAN); + return v1 == v2; + } else if (t1.equals(b.Byte)) { + byte v1 = g.getValue(r1, Bindings.BYTE); + byte v2 = g.getValue(r2, Bindings.BYTE); + return v1 == v2; + } else if (t1.equals(b.Long)) { + long v1 = g.getValue(r1, Bindings.LONG); + long v2 = g.getValue(r2, Bindings.LONG); + return v1 == v2; + } else if (t1.equals(b.IntegerArray)) { + int[] v1 = g.getValue(r1, Bindings.INT_ARRAY); + int[] v2 = g.getValue(r2, Bindings.INT_ARRAY); + return Arrays.equals(v1,v2); + } else if (t1.equals(b.FloatArray)) { + float[] v1 = g.getValue(r1, Bindings.FLOAT_ARRAY); + float[] v2 = g.getValue(r2, Bindings.FLOAT_ARRAY); + return Arrays.equals(v1,v2); + } else if (t1.equals(b.DoubleArray)) { + double[] v1 = g.getValue(r1, Bindings.DOUBLE_ARRAY); + double[] v2 = g.getValue(r2, Bindings.DOUBLE_ARRAY); + return Arrays.equals(v1,v2); + } else if (t1.equals(b.StringArray)) { + String[] v1 = g.getValue(r1, Bindings.STRING_ARRAY); + String[] v2 = g.getValue(r2, Bindings.STRING_ARRAY); + return Arrays.equals(v1,v2); + } else if (t1.equals(b.BooleanArray)) { + boolean[] v1 = g.getValue(r1, Bindings.BOOLEAN_ARRAY); + boolean[] v2 = g.getValue(r2, Bindings.BOOLEAN_ARRAY); + return Arrays.equals(v1,v2); + } else if (t1.equals(b.ByteArray)) { + byte[] v1 = g.getValue(r1, Bindings.BYTE_ARRAY); + byte[] v2 = g.getValue(r2, Bindings.BYTE_ARRAY); + return Arrays.equals(v1,v2); + } else if (t1.equals(b.LongArray)) { + long[] v1 = g.getValue(r1, Bindings.LONG_ARRAY); + long[] v2 = g.getValue(r2, Bindings.LONG_ARRAY); + return Arrays.equals(v1,v2); + } else { + Object v1 = g.getValue(r1); + Object v2 = g.getValue(r2); + return compareValue(v1, v2); + } + + } + public static boolean compareValue(Object v1, Object v2) { if (v1 instanceof Object[] && v2 instanceof Object[]) return Arrays.deepEquals((Object[])v1, (Object[])v2); diff --git a/org.simantics.interop/src/org/simantics/interop/test/TypeComparator.java b/org.simantics.interop/src/org/simantics/interop/test/TypeComparator.java index 3bd21b5..61e8a0f 100644 --- a/org.simantics.interop/src/org/simantics/interop/test/TypeComparator.java +++ b/org.simantics.interop/src/org/simantics/interop/test/TypeComparator.java @@ -1,164 +1,165 @@ -package org.simantics.interop.test; - -import java.util.ArrayList; -import java.util.Comparator; - -import org.simantics.db.ReadGraph; -import org.simantics.db.Resource; -import org.simantics.db.Statement; -import org.simantics.db.exception.DatabaseException; -import org.simantics.db.exception.DoesNotContainValueException; -import org.simantics.db.exception.ManyObjectsForFunctionalRelationException; -import org.simantics.db.exception.ServiceException; -import org.simantics.db.exception.ValidationException; -import org.simantics.layer0.Layer0; - -/** - * Object comparator that uses type of objects to check if objects are comparable. - * - * Difference value is amount of properties that have different values. If objects have no properties, the result is 0 (unreliable). - * - * - * @author Marko Luukkainen - * - */ -public class TypeComparator extends ResourceComparator { - - - ArrayList rs1 = new ArrayList(); - ArrayList rs2 = new ArrayList(); - - @Override - public int compare(ReadGraph g, Resource o1, Resource o2, boolean local) throws DatabaseException { - if (local) - return new TypeComparator().compare(g, o1, o2); - else - return compare(g, o1, o2); - } - - @Override - public int compare(ReadGraph g, Resource o1, Resource o2) throws DatabaseException{ - if (!compareType(g,o1, o2)) { - return (Integer.MAX_VALUE); - } - return propsDiffCount(g,o1, o2); - } - - protected boolean compareType(ReadGraph g,Resource r1, Resource r2) throws ServiceException, ManyObjectsForFunctionalRelationException { - Layer0 l0 = Layer0.getInstance(g); - rs1.addAll(g.getObjects(r1, l0.InstanceOf)); - rs2.addAll(g.getObjects(r2, l0.InstanceOf)); - if (rs1.size() != rs2.size()) { - rs1.clear(); - rs2.clear(); - return false; - } - Comparator rcomp = getComparator().getResourceComparator(); - getComparator().sortResource(rs1, rs2); - - for (int i = 0; i < rs1.size(); i++) { - int c = rcomp.compare(rs1.get(i), rs2.get(i)); - if (c != 0) { - rs1.clear(); - rs2.clear(); - return false; - } - } - - rs1.clear(); - rs2.clear(); - - return true; - } - - protected int propsDiffCount(ReadGraph g, Resource r1, Resource r2) throws ServiceException, DoesNotContainValueException, ValidationException { - Layer0 l0 = Layer0.getInstance(g); - ArrayList ss1 = new ArrayList(); - ArrayList ss2 = new ArrayList(); - ss1.addAll(g.getStatements(r1, l0.HasProperty)); - ss2.addAll(g.getStatements(r2, l0.HasProperty)); - - if (ss1.size() == 0 && ss2.size() == 0) - return 0; - - Comparator scomp = getComparator().getStatementComparator(); - - getComparator().sortStatement(ss1, ss2); - - int count = 1; - - int i1 = 0; - int i2 = 0; - - while (true) { - if (i1 >= ss1.size()) { - if (i2 >= ss2.size()) - break; - else { - while (i2 < ss2.size()) { - count++; - i2++; - } - break; - } - } else if (i2 >= ss2.size()) { - while (i1 < ss1.size()) { - count++; - i1++; - } - break; - } - Statement s1 = ss1.get(i1); - Statement s2 = ss2.get(i2); - if (s1.isAsserted(r1) && s2.isAsserted(r2)) { - i1++; - i2++; - continue; - } - int c = scomp.compare(s1, s2); - switch (c) { - case 0:{ - boolean b1 = g.hasValue(s1.getObject()); - boolean b2 = g.hasValue(s2.getObject()); - if (b1 == b2) { - if (b1) { - Object v1 = g.getValue(s1.getObject()); - Object v2 = g.getValue(s2.getObject()); - boolean eq = GraphComparator.compareValue(v1, v2); - - if (!eq) { - count++; - } - //System.out.println("Prop count values " + v1 + " " + v2); - } else { - count += propsDiffCount(g,s1.getObject(), s2.getObject()); - } - } else { - //System.out.println("Props count structural vs literal"); - count++; - } - i1++; - i2++; - break; - } - case -1:{ - count++; - i1++; - break; - } - - case 1:{ - count++; - i2++; - break; - } - } - - } - - ss1.clear(); - ss2.clear(); - return count; - } - -} +package org.simantics.interop.test; + +import java.util.ArrayList; +import java.util.Comparator; + +import org.simantics.db.ReadGraph; +import org.simantics.db.Resource; +import org.simantics.db.Statement; +import org.simantics.db.exception.DatabaseException; +import org.simantics.db.exception.DoesNotContainValueException; +import org.simantics.db.exception.ManyObjectsForFunctionalRelationException; +import org.simantics.db.exception.ServiceException; +import org.simantics.db.exception.ValidationException; +import org.simantics.layer0.Layer0; + +/** + * Object comparator that uses type of objects to check if objects are comparable. + * + * Difference value is amount of properties that have different values. If objects have no properties, the result is 0 (unreliable). + * + * + * @author Marko Luukkainen + * + */ +public class TypeComparator extends ResourceComparator { + + + ArrayList rs1 = new ArrayList(); + ArrayList rs2 = new ArrayList(); + + @Override + public int compare(ReadGraph g, Resource o1, Resource o2, boolean local) throws DatabaseException { + if (local) + return new TypeComparator().compare(g, o1, o2); + else + return compare(g, o1, o2); + } + + @Override + public int compare(ReadGraph g, Resource o1, Resource o2) throws DatabaseException{ + if (!compareType(g,o1, o2)) { + return (Integer.MAX_VALUE); + } + return propsDiffCount(g,o1, o2); + } + + protected boolean compareType(ReadGraph g,Resource r1, Resource r2) throws DatabaseException { + Layer0 l0 = Layer0.getInstance(g); + rs1.addAll(g.getObjects(r1, l0.InstanceOf)); + rs2.addAll(g.getObjects(r2, l0.InstanceOf)); + if (rs1.size() != rs2.size()) { + rs1.clear(); + rs2.clear(); + return false; + } + Comparator rcomp = getComparator().getResourceComparator(); + getComparator().sortResource(rs1, rs2); + + for (int i = 0; i < rs1.size(); i++) { + int c = rcomp.compare(rs1.get(i), rs2.get(i)); + if (c != 0) { + rs1.clear(); + rs2.clear(); + return false; + } + } + + rs1.clear(); + rs2.clear(); + + return true; + } + + protected int propsDiffCount(ReadGraph g, Resource r1, Resource r2) throws DatabaseException { + Layer0 l0 = Layer0.getInstance(g); + ArrayList ss1 = new ArrayList(); + ArrayList ss2 = new ArrayList(); + ss1.addAll(g.getStatements(r1, l0.HasProperty)); + ss2.addAll(g.getStatements(r2, l0.HasProperty)); + + if (ss1.size() == 0 && ss2.size() == 0) + return 0; + + Comparator scomp = getComparator().getStatementComparator(); + + getComparator().sortStatement(ss1, ss2); + + int count = 1; + + int i1 = 0; + int i2 = 0; + + while (true) { + if (i1 >= ss1.size()) { + if (i2 >= ss2.size()) + break; + else { + while (i2 < ss2.size()) { + count++; + i2++; + } + break; + } + } else if (i2 >= ss2.size()) { + while (i1 < ss1.size()) { + count++; + i1++; + } + break; + } + Statement s1 = ss1.get(i1); + Statement s2 = ss2.get(i2); + if (s1.isAsserted(r1) && s2.isAsserted(r2)) { + i1++; + i2++; + continue; + } + int c = scomp.compare(s1, s2); + switch (c) { + case 0:{ + boolean b1 = g.hasValue(s1.getObject()); + boolean b2 = g.hasValue(s2.getObject()); + if (b1 == b2) { + if (b1) { +// Object v1 = g.getValue(s1.getObject()); +// Object v2 = g.getValue(s2.getObject()); +// boolean eq = GraphComparator.compareValue(v1, v2); + boolean eq = GraphComparator.compareValue(g, l0 , s1.getObject(), s2.getObject()); + + if (!eq) { + count++; + } + //System.out.println("Prop count values " + v1 + " " + v2); + } else { + count += propsDiffCount(g,s1.getObject(), s2.getObject()); + } + } else { + //System.out.println("Props count structural vs literal"); + count++; + } + i1++; + i2++; + break; + } + case -1:{ + count++; + i1++; + break; + } + + case 1:{ + count++; + i2++; + break; + } + } + + } + + ss1.clear(); + ss2.clear(); + return count; + } + +} -- 2.45.2