IGNITE-1917: Binary protocol performance optimizations.
Project: http://git-wip-us.apache.org/repos/asf/ignite/repo Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/4a1af37e Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/4a1af37e Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/4a1af37e Branch: refs/heads/ignite-sql-opt Commit: 4a1af37e39783d57b924138fb1e4aeddc137fc8a Parents: 5ea0625 Author: vozerov-gridgain <voze...@gridgain.com> Authored: Fri Nov 20 09:29:19 2015 +0300 Committer: vozerov-gridgain <voze...@gridgain.com> Committed: Fri Nov 20 09:29:19 2015 +0300 ---------------------------------------------------------------------- .../apache/ignite/internal/IgniteKernal.java | 5 +- .../internal/portable/BinaryEnumCache.java | 69 + .../internal/portable/BinaryFieldAccessor.java | 805 ++++++++ .../portable/BinaryMetadataCollector.java | 66 +- .../internal/portable/BinaryObjectEx.java | 8 +- .../internal/portable/BinaryObjectImpl.java | 47 +- .../portable/BinaryObjectOffheapImpl.java | 105 +- .../internal/portable/BinaryReaderExImpl.java | 1823 +++++++++--------- .../internal/portable/BinaryReaderHandles.java | 108 ++ .../portable/BinaryThreadLocalContext.java | 69 + .../internal/portable/BinaryTypeImpl.java | 1 + .../internal/portable/BinaryWriteMode.java | 178 ++ .../internal/portable/BinaryWriterExImpl.java | 866 ++++----- .../internal/portable/BinaryWriterHandles.java | 101 + .../portable/BinaryWriterSchemaHolder.java | 148 ++ .../portable/GridPortableMarshaller.java | 11 +- .../portable/PortableClassDescriptor.java | 747 +------ .../internal/portable/PortableContext.java | 8 +- .../portable/PortableReaderContext.java | 105 - .../internal/portable/PortableSchema.java | 405 ++-- .../PortableThreadLocalMemoryAllocator.java | 162 -- .../ignite/internal/portable/PortableUtils.java | 120 +- .../builder/BinaryObjectBuilderImpl.java | 8 +- .../portable/builder/PortableBuilderReader.java | 54 +- .../streams/PortableAbstractOutputStream.java | 40 +- .../streams/PortableHeapInputStream.java | 17 + .../streams/PortableHeapOutputStream.java | 100 +- .../streams/PortableMemoryAllocator.java | 67 +- .../streams/PortableMemoryAllocatorChunk.java | 117 ++ .../streams/PortableOffheapOutputStream.java | 53 +- .../portable/streams/PortableOutputStream.java | 79 + .../streams/PortableSimpleMemoryAllocator.java | 66 - .../PlatformBigEndianOutputStreamImpl.java | 30 + .../memory/PlatformOutputStreamImpl.java | 63 + .../ignite/internal/util/GridEnumCache.java | 56 - .../portable/BinaryMarshallerSelfTest.java | 30 +- .../testframework/junits/GridAbstractTest.java | 4 +- .../Cache/Query/CacheQueriesTest.cs | 2 - 38 files changed, 3832 insertions(+), 2911 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/ignite/blob/4a1af37e/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java index 2b6eaad..2e8520e 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteKernal.java @@ -102,7 +102,6 @@ import org.apache.ignite.internal.processors.cache.GridCacheProcessor; import org.apache.ignite.internal.processors.cache.GridCacheUtilityKey; import org.apache.ignite.internal.processors.cache.IgniteCacheProxy; import org.apache.ignite.internal.processors.cache.IgniteInternalCache; -import org.apache.ignite.internal.processors.cache.portable.CacheObjectBinaryProcessor; import org.apache.ignite.internal.processors.cache.portable.CacheObjectBinaryProcessorImpl; import org.apache.ignite.internal.processors.cacheobject.IgniteCacheObjectProcessor; import org.apache.ignite.internal.processors.clock.GridClockSyncProcessor; @@ -132,7 +131,7 @@ import org.apache.ignite.internal.processors.service.GridServiceProcessor; import org.apache.ignite.internal.processors.session.GridTaskSessionProcessor; import org.apache.ignite.internal.processors.task.GridTaskProcessor; import org.apache.ignite.internal.processors.timeout.GridTimeoutProcessor; -import org.apache.ignite.internal.util.GridEnumCache; +import org.apache.ignite.internal.portable.BinaryEnumCache; import org.apache.ignite.internal.util.GridTimerTask; import org.apache.ignite.internal.util.future.GridFinishedFuture; import org.apache.ignite.internal.util.future.GridFutureAdapter; @@ -1941,7 +1940,7 @@ public class IgniteKernal implements IgniteEx, IgniteMXBean, Externalizable { // Clean internal class/classloader caches to avoid stopped contexts held in memory. U.clearClassCache(); MarshallerExclusions.clearCache(); - GridEnumCache.clear(); + BinaryEnumCache.clear(); gw.writeLock(); http://git-wip-us.apache.org/repos/asf/ignite/blob/4a1af37e/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryEnumCache.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryEnumCache.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryEnumCache.java new file mode 100644 index 0000000..fc042e5 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryEnumCache.java @@ -0,0 +1,69 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.portable; + +import org.apache.ignite.binary.BinaryObjectException; +import org.jsr166.ConcurrentHashMap8; + +import java.util.concurrent.ConcurrentMap; + +/** + * Cache for enum constants. + */ +public class BinaryEnumCache { + /** Cache for enum constants. */ + private static final ConcurrentMap<Class<?>, Object[]> ENUM_CACHE = new ConcurrentHashMap8<>(); + + /** + * Get value for the given class and ordinal. + * + * @param cls Class. + * @param ord Ordinal. + * @return Value. + * @throws BinaryObjectException In case of invalid ordinal. + */ + @SuppressWarnings("unchecked") + public static <T> T get(Class<?> cls, int ord) throws BinaryObjectException { + assert cls != null; + + if (ord >= 0) { + Object[] vals = ENUM_CACHE.get(cls); + + if (vals == null) { + vals = cls.getEnumConstants(); + + ENUM_CACHE.putIfAbsent(cls, vals); + } + + if (ord < vals.length) + return (T) vals[ord]; + else + throw new BinaryObjectException("Failed to get enum value for ordinal (do you have correct class " + + "version?) [cls=" + cls.getName() + ", ordinal=" + ord + ", totalValues=" + vals.length + ']'); + } + else + return null; + } + + /** + * Clears cache. + */ + public static void clear() { + ENUM_CACHE.clear(); + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/4a1af37e/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldAccessor.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldAccessor.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldAccessor.java new file mode 100644 index 0000000..0eda375 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryFieldAccessor.java @@ -0,0 +1,805 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.ignite.internal.portable; + +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.internal.util.GridUnsafe; +import sun.misc.Unsafe; + +import java.lang.reflect.Field; +import java.math.BigDecimal; +import java.sql.Timestamp; +import java.util.Collection; +import java.util.Date; +import java.util.Map; +import java.util.UUID; + +/** + * Field accessor to speedup access. + */ +public abstract class BinaryFieldAccessor { + /** Field ID. */ + protected final int id; + + /** Mode. */ + protected final BinaryWriteMode mode; + + /** + * Create accessor for the field. + * + * @param field Field. + * @param id FIeld ID. + * @return Accessor. + */ + public static BinaryFieldAccessor create(Field field, int id) { + BinaryWriteMode mode = PortableUtils.mode(field.getType()); + + switch (mode) { + case P_BYTE: + return new BytePrimitiveAccessor(field, id); + + case P_BOOLEAN: + return new BooleanPrimitiveAccessor(field, id); + + case P_SHORT: + return new ShortPrimitiveAccessor(field, id); + + case P_CHAR: + return new CharPrimitiveAccessor(field, id); + + case P_INT: + return new IntPrimitiveAccessor(field, id); + + case P_LONG: + return new LongPrimitiveAccessor(field, id); + + case P_FLOAT: + return new FloatPrimitiveAccessor(field, id); + + case P_DOUBLE: + return new DoublePrimitiveAccessor(field, id); + + default: + return new DefaultAccessor(field, id, mode); + } + } + + /** + * Protected constructor. + * + * @param id Field ID. + * @param mode Mode; + */ + protected BinaryFieldAccessor(int id, BinaryWriteMode mode) { + assert id != 0; + assert mode != null; + + this.id = id; + this.mode = mode; + } + + /** + * Get mode. + * + * @return Mode. + */ + public BinaryWriteMode mode() { + return mode; + } + + /** + * Write field. + * + * @param obj Object. + * @param writer Writer. + * @throws BinaryObjectException If failed. + */ + public abstract void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException; + + /** + * Read field. + * + * @param obj Object. + * @param reader Reader. + * @throws BinaryObjectException If failed. + */ + public abstract void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException; + + /** + * Base primitive field accessor. + */ + private static abstract class AbstractPrimitiveAccessor extends BinaryFieldAccessor { + /** Unsafe instance. */ + protected static final Unsafe UNSAFE = GridUnsafe.unsafe(); + + /** Offset. */ + protected final long offset; + + /** + * Constructor. + * + * @param field Field. + * @param id Field ID. + * @param mode Mode. + */ + protected AbstractPrimitiveAccessor(Field field, int id, BinaryWriteMode mode) { + super(id, mode); + + assert field != null; + + offset = UNSAFE.objectFieldOffset(field); + } + } + + /** + * Byte field accessor. + */ + private static class BytePrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public BytePrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_BYTE); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + byte val = UNSAFE.getByte(obj, offset); + + writer.writeByteFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + byte val = reader.readByte(id); + + UNSAFE.putByte(obj, offset, val); + } + } + + /** + * Boolean field accessor. + */ + private static class BooleanPrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public BooleanPrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_BOOLEAN); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + boolean val = UNSAFE.getBoolean(obj, offset); + + writer.writeBooleanFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + boolean val = reader.readBoolean(id); + + UNSAFE.putBoolean(obj, offset, val); + } + } + + /** + * Short field accessor. + */ + private static class ShortPrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public ShortPrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_SHORT); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + short val = UNSAFE.getShort(obj, offset); + + writer.writeShortFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + short val = reader.readShort(id); + + UNSAFE.putShort(obj, offset, val); + } + } + + /** + * Char field accessor. + */ + private static class CharPrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public CharPrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_CHAR); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + char val = UNSAFE.getChar(obj, offset); + + writer.writeCharFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + char val = reader.readChar(id); + + UNSAFE.putChar(obj, offset, val); + } + } + + /** + * Int field accessor. + */ + private static class IntPrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public IntPrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_INT); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + int val = UNSAFE.getInt(obj, offset); + + writer.writeIntFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + int val = reader.readInt(id); + + UNSAFE.putInt(obj, offset, val); + } + } + + /** + * Long field accessor. + */ + private static class LongPrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public LongPrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_LONG); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + long val = UNSAFE.getLong(obj, offset); + + writer.writeLongFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + long val = reader.readLong(id); + + UNSAFE.putLong(obj, offset, val); + } + } + + /** + * Float field accessor. + */ + private static class FloatPrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public FloatPrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_FLOAT); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + float val = UNSAFE.getFloat(obj, offset); + + writer.writeFloatFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + float val = reader.readFloat(id); + + UNSAFE.putFloat(obj, offset, val); + } + } + + /** + * Double field accessor. + */ + private static class DoublePrimitiveAccessor extends AbstractPrimitiveAccessor { + /** + * Constructor. + * + * @param field Field. + */ + public DoublePrimitiveAccessor(Field field, int id) { + super(field, id, BinaryWriteMode.P_DOUBLE); + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + writer.writeFieldIdNoSchemaUpdate(id); + + double val = UNSAFE.getDouble(obj, offset); + + writer.writeDoubleFieldPrimitive(val); + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + double val = reader.readDouble(id); + + UNSAFE.putDouble(obj, offset, val); + } + } + + /** + * Default accessor. + */ + private static class DefaultAccessor extends BinaryFieldAccessor { + /** Target field. */ + private final Field field; + + /** + * Constructor. + * + * @param field Field. + * @param id Field ID. + * @param mode Mode. + */ + public DefaultAccessor(Field field, int id, BinaryWriteMode mode) { + super(id, mode); + + assert field != null; + + this.field = field; + } + + /** {@inheritDoc} */ + @Override public void write(Object obj, BinaryWriterExImpl writer) throws BinaryObjectException { + assert obj != null; + assert writer != null; + + writer.writeFieldIdNoSchemaUpdate(id); + + Object val; + + try { + val = field.get(obj); + } + catch (IllegalAccessException e) { + throw new BinaryObjectException("Failed to get value for field: " + field, e); + } + + switch (mode) { + case BYTE: + writer.writeByteField((Byte) val); + + break; + + case SHORT: + writer.writeShortField((Short) val); + + break; + + case INT: + writer.writeIntField((Integer) val); + + break; + + case LONG: + writer.writeLongField((Long)val); + + break; + + case FLOAT: + writer.writeFloatField((Float)val); + + break; + + case DOUBLE: + writer.writeDoubleField((Double)val); + + break; + + case CHAR: + writer.writeCharField((Character)val); + + break; + + case BOOLEAN: + writer.writeBooleanField((Boolean)val); + + break; + + case DECIMAL: + writer.writeDecimalField((BigDecimal)val); + + break; + + case STRING: + writer.writeStringField((String)val); + + break; + + case UUID: + writer.writeUuidField((UUID)val); + + break; + + case DATE: + writer.writeDateField((Date)val); + + break; + + case TIMESTAMP: + writer.writeTimestampField((Timestamp)val); + + break; + + case BYTE_ARR: + writer.writeByteArrayField((byte[])val); + + break; + + case SHORT_ARR: + writer.writeShortArrayField((short[])val); + + break; + + case INT_ARR: + writer.writeIntArrayField((int[])val); + + break; + + case LONG_ARR: + writer.writeLongArrayField((long[])val); + + break; + + case FLOAT_ARR: + writer.writeFloatArrayField((float[])val); + + break; + + case DOUBLE_ARR: + writer.writeDoubleArrayField((double[])val); + + break; + + case CHAR_ARR: + writer.writeCharArrayField((char[])val); + + break; + + case BOOLEAN_ARR: + writer.writeBooleanArrayField((boolean[])val); + + break; + + case DECIMAL_ARR: + writer.writeDecimalArrayField((BigDecimal[])val); + + break; + + case STRING_ARR: + writer.writeStringArrayField((String[])val); + + break; + + case UUID_ARR: + writer.writeUuidArrayField((UUID[])val); + + break; + + case DATE_ARR: + writer.writeDateArrayField((Date[])val); + + break; + + case TIMESTAMP_ARR: + writer.writeTimestampArrayField((Timestamp[])val); + + break; + + case OBJECT_ARR: + writer.writeObjectArrayField((Object[])val); + + break; + + case COL: + writer.writeCollectionField((Collection<?>)val); + + break; + + case MAP: + writer.writeMapField((Map<?, ?>)val); + + break; + + case MAP_ENTRY: + writer.writeMapEntryField((Map.Entry<?, ?>)val); + + break; + + case PORTABLE_OBJ: + writer.writePortableObjectField((BinaryObjectImpl)val); + + break; + + case ENUM: + writer.writeEnumField((Enum<?>)val); + + break; + + case ENUM_ARR: + writer.writeEnumArrayField((Object[])val); + + break; + + case PORTABLE: + case EXTERNALIZABLE: + case OBJECT: + writer.writeObjectField(val); + + break; + + case CLASS: + writer.writeClassField((Class)val); + + break; + + default: + assert false : "Invalid mode: " + mode; + } + } + + /** {@inheritDoc} */ + @Override public void read(Object obj, BinaryReaderExImpl reader) throws BinaryObjectException { + Object val = null; + + switch (mode) { + case BYTE: + val = reader.readByteNullable(id); + + break; + + case SHORT: + val = reader.readShortNullable(id); + + break; + + case INT: + val = reader.readIntNullable(id); + + break; + + case LONG: + val = reader.readLongNullable(id); + + break; + + case FLOAT: + val = reader.readFloatNullable(id); + + break; + + case DOUBLE: + val = reader.readDoubleNullable(id); + + break; + + case CHAR: + val = reader.readCharNullable(id); + + break; + + case BOOLEAN: + val = reader.readBooleanNullable(id); + + break; + + case DECIMAL: + val = reader.readDecimal(id); + + break; + + case STRING: + val = reader.readString(id); + + break; + + case UUID: + val = reader.readUuid(id); + + break; + + case DATE: + val = reader.readDate(id); + + break; + + case TIMESTAMP: + val = reader.readTimestamp(id); + + break; + + case BYTE_ARR: + val = reader.readByteArray(id); + + break; + + case SHORT_ARR: + val = reader.readShortArray(id); + + break; + + case INT_ARR: + val = reader.readIntArray(id); + + break; + + case LONG_ARR: + val = reader.readLongArray(id); + + break; + + case FLOAT_ARR: + val = reader.readFloatArray(id); + + break; + + case DOUBLE_ARR: + val = reader.readDoubleArray(id); + + break; + + case CHAR_ARR: + val = reader.readCharArray(id); + + break; + + case BOOLEAN_ARR: + val = reader.readBooleanArray(id); + + break; + + case DECIMAL_ARR: + val = reader.readDecimalArray(id); + + break; + + case STRING_ARR: + val = reader.readStringArray(id); + + break; + + case UUID_ARR: + val = reader.readUuidArray(id); + + break; + + case DATE_ARR: + val = reader.readDateArray(id); + + break; + + case TIMESTAMP_ARR: + val = reader.readTimestampArray(id); + + break; + + case OBJECT_ARR: + val = reader.readObjectArray(id); + + break; + + case COL: + val = reader.readCollection(id, null); + + break; + + case MAP: + val = reader.readMap(id, null); + + break; + + case MAP_ENTRY: + val = reader.readMapEntry(id); + + break; + + case PORTABLE_OBJ: + val = reader.readPortableObject(id); + + break; + + case ENUM: + val = reader.readEnum(id, field.getType()); + + break; + + case ENUM_ARR: + val = reader.readEnumArray(id, field.getType().getComponentType()); + + break; + + case PORTABLE: + case EXTERNALIZABLE: + case OBJECT: + val = reader.readObject(id); + + break; + + case CLASS: + val = reader.readClass(id); + + break; + + default: + assert false : "Invalid mode: " + mode; + } + + try { + if (val != null || !field.getType().isPrimitive()) + field.set(obj, val); + } + catch (IllegalAccessException e) { + throw new BinaryObjectException("Failed to set value for field: " + field, e); + } + } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/4a1af37e/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryMetadataCollector.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryMetadataCollector.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryMetadataCollector.java index 28eb1d0..6ad0ad1 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryMetadataCollector.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryMetadataCollector.java @@ -82,163 +82,163 @@ class BinaryMetadataCollector implements BinaryWriter { /** {@inheritDoc} */ @Override public void writeByte(String fieldName, byte val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.BYTE); + add(fieldName, BinaryWriteMode.BYTE); } /** {@inheritDoc} */ @Override public void writeShort(String fieldName, short val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.SHORT); + add(fieldName, BinaryWriteMode.SHORT); } /** {@inheritDoc} */ @Override public void writeInt(String fieldName, int val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.INT); + add(fieldName, BinaryWriteMode.INT); } /** {@inheritDoc} */ @Override public void writeLong(String fieldName, long val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.LONG); + add(fieldName, BinaryWriteMode.LONG); } /** {@inheritDoc} */ @Override public void writeFloat(String fieldName, float val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.FLOAT); + add(fieldName, BinaryWriteMode.FLOAT); } /** {@inheritDoc} */ @Override public void writeDouble(String fieldName, double val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.DOUBLE); + add(fieldName, BinaryWriteMode.DOUBLE); } /** {@inheritDoc} */ @Override public void writeChar(String fieldName, char val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.CHAR); + add(fieldName, BinaryWriteMode.CHAR); } /** {@inheritDoc} */ @Override public void writeBoolean(String fieldName, boolean val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.BOOLEAN); + add(fieldName, BinaryWriteMode.BOOLEAN); } /** {@inheritDoc} */ @Override public void writeDecimal(String fieldName, @Nullable BigDecimal val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.DECIMAL); + add(fieldName, BinaryWriteMode.DECIMAL); } /** {@inheritDoc} */ @Override public void writeString(String fieldName, @Nullable String val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.STRING); + add(fieldName, BinaryWriteMode.STRING); } /** {@inheritDoc} */ @Override public void writeUuid(String fieldName, @Nullable UUID val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.UUID); + add(fieldName, BinaryWriteMode.UUID); } /** {@inheritDoc} */ @Override public void writeDate(String fieldName, @Nullable Date val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.DATE); + add(fieldName, BinaryWriteMode.DATE); } /** {@inheritDoc} */ @Override public void writeTimestamp(String fieldName, @Nullable Timestamp val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.TIMESTAMP); + add(fieldName, BinaryWriteMode.TIMESTAMP); } /** {@inheritDoc} */ @Override public <T extends Enum<?>> void writeEnum(String fieldName, T val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.ENUM); + add(fieldName, BinaryWriteMode.ENUM); } /** {@inheritDoc} */ @Override public <T extends Enum<?>> void writeEnumArray(String fieldName, T[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.ENUM_ARR); + add(fieldName, BinaryWriteMode.ENUM_ARR); } /** {@inheritDoc} */ @Override public void writeObject(String fieldName, @Nullable Object obj) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.OBJECT); + add(fieldName, BinaryWriteMode.OBJECT); } /** {@inheritDoc} */ @Override public void writeByteArray(String fieldName, @Nullable byte[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.BYTE_ARR); + add(fieldName, BinaryWriteMode.BYTE_ARR); } /** {@inheritDoc} */ @Override public void writeShortArray(String fieldName, @Nullable short[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.SHORT_ARR); + add(fieldName, BinaryWriteMode.SHORT_ARR); } /** {@inheritDoc} */ @Override public void writeIntArray(String fieldName, @Nullable int[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.INT_ARR); + add(fieldName, BinaryWriteMode.INT_ARR); } /** {@inheritDoc} */ @Override public void writeLongArray(String fieldName, @Nullable long[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.LONG_ARR); + add(fieldName, BinaryWriteMode.LONG_ARR); } /** {@inheritDoc} */ @Override public void writeFloatArray(String fieldName, @Nullable float[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.FLOAT_ARR); + add(fieldName, BinaryWriteMode.FLOAT_ARR); } /** {@inheritDoc} */ @Override public void writeDoubleArray(String fieldName, @Nullable double[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.DOUBLE_ARR); + add(fieldName, BinaryWriteMode.DOUBLE_ARR); } /** {@inheritDoc} */ @Override public void writeCharArray(String fieldName, @Nullable char[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.CHAR_ARR); + add(fieldName, BinaryWriteMode.CHAR_ARR); } /** {@inheritDoc} */ @Override public void writeBooleanArray(String fieldName, @Nullable boolean[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.BOOLEAN_ARR); + add(fieldName, BinaryWriteMode.BOOLEAN_ARR); } /** {@inheritDoc} */ @Override public void writeDecimalArray(String fieldName, @Nullable BigDecimal[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.DECIMAL_ARR); + add(fieldName, BinaryWriteMode.DECIMAL_ARR); } /** {@inheritDoc} */ @Override public void writeStringArray(String fieldName, @Nullable String[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.STRING_ARR); + add(fieldName, BinaryWriteMode.STRING_ARR); } /** {@inheritDoc} */ @Override public void writeUuidArray(String fieldName, @Nullable UUID[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.UUID_ARR); + add(fieldName, BinaryWriteMode.UUID_ARR); } /** {@inheritDoc} */ @Override public void writeDateArray(String fieldName, @Nullable Date[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.DATE_ARR); + add(fieldName, BinaryWriteMode.DATE_ARR); } /** {@inheritDoc} */ @Override public void writeTimestampArray(String fieldName, @Nullable Timestamp[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.TIMESTAMP_ARR); + add(fieldName, BinaryWriteMode.TIMESTAMP_ARR); } /** {@inheritDoc} */ @Override public void writeObjectArray(String fieldName, @Nullable Object[] val) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.OBJECT_ARR); + add(fieldName, BinaryWriteMode.OBJECT_ARR); } /** {@inheritDoc} */ @Override public <T> void writeCollection(String fieldName, @Nullable Collection<T> col) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.COL); + add(fieldName, BinaryWriteMode.COL); } /** {@inheritDoc} */ @Override public <K, V> void writeMap(String fieldName, @Nullable Map<K, V> map) throws BinaryObjectException { - add(fieldName, PortableClassDescriptor.Mode.MAP); + add(fieldName, BinaryWriteMode.MAP); } /** {@inheritDoc} */ @@ -257,7 +257,7 @@ class BinaryMetadataCollector implements BinaryWriter { * @param mode Field mode. * @throws BinaryObjectException In case of error. */ - private void add(String name, PortableClassDescriptor.Mode mode) throws BinaryObjectException { + private void add(String name, BinaryWriteMode mode) throws BinaryObjectException { assert name != null; int fieldTypeId = mode.typeId(); http://git-wip-us.apache.org/repos/asf/ignite/blob/4a1af37e/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java index 6902675..597fad5 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectEx.java @@ -79,7 +79,7 @@ public abstract class BinaryObjectEx implements BinaryObject { * @param fieldName Field name. * @return Field value. */ - @Nullable protected abstract <F> F field(PortableReaderContext ctx, String fieldName); + @Nullable protected abstract <F> F field(BinaryReaderHandles ctx, String fieldName); /** * Get schema ID. @@ -157,7 +157,7 @@ public abstract class BinaryObjectEx implements BinaryObject { * @param handles Handles for already traversed objects. * @return String representation. */ - private String toString(PortableReaderContext ctx, IdentityHashMap<BinaryObject, Integer> handles) { + private String toString(BinaryReaderHandles ctx, IdentityHashMap<BinaryObject, Integer> handles) { int idHash = System.identityHashCode(this); BinaryType meta; @@ -232,9 +232,9 @@ public abstract class BinaryObjectEx implements BinaryObject { /** {@inheritDoc} */ @Override public String toString() { try { - PortableReaderContext ctx = new PortableReaderContext(); + BinaryReaderHandles ctx = new BinaryReaderHandles(); - ctx.setPortableHandler(start(), this); + ctx.put(start(), this); return toString(ctx, new IdentityHashMap<BinaryObject, Integer>()); } http://git-wip-us.apache.org/repos/asf/ignite/blob/4a1af37e/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java index d9339f8..7ab9497 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectImpl.java @@ -25,7 +25,6 @@ import org.apache.ignite.internal.processors.cache.CacheObject; import org.apache.ignite.internal.processors.cache.CacheObjectContext; import org.apache.ignite.internal.processors.cache.KeyCacheObject; import org.apache.ignite.internal.processors.cache.portable.CacheObjectBinaryProcessorImpl; -import org.apache.ignite.internal.util.typedef.internal.A; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.plugin.extensions.communication.Message; import org.apache.ignite.plugin.extensions.communication.MessageReader; @@ -33,7 +32,6 @@ import org.apache.ignite.plugin.extensions.communication.MessageWriter; import org.apache.ignite.binary.BinaryObjectException; import org.apache.ignite.binary.BinaryType; import org.apache.ignite.binary.BinaryObject; -import org.apache.ignite.binary.BinaryField; import org.jetbrains.annotations.Nullable; import java.io.Externalizable; @@ -257,17 +255,13 @@ public final class BinaryObjectImpl extends BinaryObjectEx implements Externaliz /** {@inheritDoc} */ @SuppressWarnings("unchecked") @Nullable @Override public <F> F field(String fieldName) throws BinaryObjectException { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null); - - return (F)reader.unmarshalField(fieldName); + return (F)newReader().unmarshalField(fieldName); } /** {@inheritDoc} */ @SuppressWarnings("unchecked") @Nullable @Override public <F> F field(int fieldId) throws BinaryObjectException { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null); - - return (F)reader.unmarshalField(fieldId); + return (F)newReader().unmarshalField(fieldId); } /** {@inheritDoc} */ @@ -400,11 +394,13 @@ public final class BinaryObjectImpl extends BinaryObjectEx implements Externaliz break; - default: { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null); + default: + BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, PortableHeapInputStream.create(arr, fieldPos), + null, new BinaryReaderHandles()); - val = reader.unmarshalFieldByAbsolutePosition(fieldPos); - } + val = reader.unmarshal(); + + break; } return (F)val; @@ -412,21 +408,15 @@ public final class BinaryObjectImpl extends BinaryObjectEx implements Externaliz /** {@inheritDoc} */ @SuppressWarnings("unchecked") - @Nullable @Override protected <F> F field(PortableReaderContext rCtx, String fieldName) { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, - new PortableHeapInputStream(arr), - start, - null, - rCtx); + @Nullable @Override protected <F> F field(BinaryReaderHandles rCtx, String fieldName) { + BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, PortableHeapInputStream.create(arr, start), null, rCtx); return (F)reader.unmarshalField(fieldName); } /** {@inheritDoc} */ @Override public boolean hasField(String fieldName) { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null); - - return reader.hasField(fieldName); + return newReader().hasField(fieldName); } /** {@inheritDoc} */ @@ -458,9 +448,7 @@ public final class BinaryObjectImpl extends BinaryObjectEx implements Externaliz /** {@inheritDoc} */ @Override protected PortableSchema createSchema() { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null); - - return reader.getOrCreateSchema(); + return newReader().getOrCreateSchema(); } /** {@inheritDoc} */ @@ -569,7 +557,7 @@ public final class BinaryObjectImpl extends BinaryObjectEx implements Externaliz */ private Object deserializeValue() { // TODO: IGNITE-1272 - Deserialize with proper class loader. - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, arr, start, null); + BinaryReaderExImpl reader = newReader(); Object obj0 = reader.deserialize(); @@ -582,4 +570,13 @@ public final class BinaryObjectImpl extends BinaryObjectEx implements Externaliz return obj0; } + + /** + * Create new reader for this object. + * + * @return Reader. + */ + private BinaryReaderExImpl newReader() { + return new BinaryReaderExImpl(ctx, PortableHeapInputStream.create(arr, start), null, new BinaryReaderHandles()); + } } \ No newline at end of file http://git-wip-us.apache.org/repos/asf/ignite/blob/4a1af37e/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java index a71c98a..6f9190a 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/BinaryObjectOffheapImpl.java @@ -17,18 +17,11 @@ package org.apache.ignite.internal.portable; -import java.io.Externalizable; -import java.io.IOException; -import java.io.ObjectInput; -import java.io.ObjectOutput; -import java.math.BigDecimal; -import java.math.BigInteger; -import java.nio.ByteBuffer; -import java.sql.Timestamp; -import java.util.Date; -import java.util.UUID; - import org.apache.ignite.IgniteCheckedException; +import org.apache.ignite.binary.BinaryField; +import org.apache.ignite.binary.BinaryObject; +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.binary.BinaryType; import org.apache.ignite.internal.portable.streams.PortableOffheapInputStream; import org.apache.ignite.internal.processors.cache.CacheObject; import org.apache.ignite.internal.processors.cache.CacheObjectContext; @@ -37,13 +30,20 @@ import org.apache.ignite.internal.util.typedef.internal.A; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.plugin.extensions.communication.MessageReader; import org.apache.ignite.plugin.extensions.communication.MessageWriter; -import org.apache.ignite.binary.BinaryObjectException; -import org.apache.ignite.binary.BinaryType; -import org.apache.ignite.binary.BinaryObject; -import org.apache.ignite.binary.BinaryField; import org.jetbrains.annotations.Nullable; import sun.misc.Unsafe; +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectOutput; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.nio.ByteBuffer; +import java.sql.Timestamp; +import java.util.Date; +import java.util.UUID; + import static java.nio.charset.StandardCharsets.UTF_8; import static org.apache.ignite.internal.portable.GridPortableMarshaller.BOOLEAN; import static org.apache.ignite.internal.portable.GridPortableMarshaller.BYTE; @@ -131,12 +131,7 @@ public class BinaryObjectOffheapImpl extends BinaryObjectEx implements Externali /** {@inheritDoc} */ @Override protected PortableSchema createSchema() { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, - new PortableOffheapInputStream(ptr, size, false), - start, - null); - - return reader.getOrCreateSchema(); + return newReader().getOrCreateSchema(); } /** {@inheritDoc} */ @@ -170,23 +165,13 @@ public class BinaryObjectOffheapImpl extends BinaryObjectEx implements Externali /** {@inheritDoc} */ @SuppressWarnings("unchecked") @Nullable @Override public <F> F field(String fieldName) throws BinaryObjectException { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, - new PortableOffheapInputStream(ptr, size, false), - start, - null); - - return (F)reader.unmarshalField(fieldName); + return (F)newReader().unmarshalField(fieldName); } /** {@inheritDoc} */ @SuppressWarnings("unchecked") @Nullable @Override public <F> F field(int fieldId) throws BinaryObjectException { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, - new PortableOffheapInputStream(ptr, size, false), - start, - null); - - return (F)reader.unmarshalField(fieldId); + return (F)newReader().unmarshalField(fieldId); } /** {@inheritDoc} */ @@ -320,14 +305,16 @@ public class BinaryObjectOffheapImpl extends BinaryObjectEx implements Externali break; - default: { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, - new PortableOffheapInputStream(ptr, size, false), - start, - null); + default: + PortableOffheapInputStream stream = new PortableOffheapInputStream(ptr, size, false); - val = reader.unmarshalFieldByAbsolutePosition(fieldPos); - } + stream.position(fieldPos); + + BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, stream, null, new BinaryReaderHandles()); + + val = reader.unmarshal(); + + break; } return (F)val; @@ -335,24 +322,19 @@ public class BinaryObjectOffheapImpl extends BinaryObjectEx implements Externali /** {@inheritDoc} */ @SuppressWarnings("unchecked") - @Nullable @Override protected <F> F field(PortableReaderContext rCtx, String fieldName) { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, - new PortableOffheapInputStream(ptr, size, false), - start, - null, - rCtx); + @Nullable @Override protected <F> F field(BinaryReaderHandles rCtx, String fieldName) { + PortableOffheapInputStream stream = new PortableOffheapInputStream(ptr, size, false); + + stream.position(start); + + BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, stream, null, rCtx); return (F)reader.unmarshalField(fieldName); } /** {@inheritDoc} */ @Override public boolean hasField(String fieldName) { - BinaryReaderExImpl reader = new BinaryReaderExImpl(ctx, - new PortableOffheapInputStream(ptr, size, false), - start, - null); - - return reader.hasField(fieldName); + return newReader().hasField(fieldName); } /** {@inheritDoc} */ @@ -438,12 +420,19 @@ public class BinaryObjectOffheapImpl extends BinaryObjectEx implements Externali */ private Object deserializeValue() { // TODO: IGNITE-1272 - Deserialize with proper class loader. - BinaryReaderExImpl reader = new BinaryReaderExImpl( - ctx, - new PortableOffheapInputStream(ptr, size, false), - start, - null); + return newReader().deserialize(); + } + + /** + * Create new reader for this object. + * + * @return Reader. + */ + private BinaryReaderExImpl newReader() { + PortableOffheapInputStream stream = new PortableOffheapInputStream(ptr, size, false); + + stream.position(start); - return reader.deserialize(); + return new BinaryReaderExImpl(ctx, stream, null, new BinaryReaderHandles()); } } \ No newline at end of file