This is an automated email from the ASF dual-hosted git repository.
chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-fury.git
The following commit(s) were added to refs/heads/main by this push:
new 9ac3e478 feat(java): concat write classname flag with package name
(#1523)
9ac3e478 is described below
commit 9ac3e478e7b3ceda065b4faac6e60d967f2cb8d4
Author: Shawn Yang <[email protected]>
AuthorDate: Tue Apr 16 10:55:21 2024 +0800
feat(java): concat write classname flag with package name (#1523)
## What does this PR do?
This PR concats write classname flag with package name, which can save
one byte for unregistred classname writing
<!-- Describe the purpose of this PR. -->
## Related issues
<!--
Is there any related issue? Please attach here.
- #xxxx0
- #xxxx1
- #xxxx2
-->
## Does this PR introduce any user-facing change?
<!--
If any user-facing interface changes, please [open an
issue](https://github.com/apache/incubator-fury/issues/new/choose)
describing the need to do so and update the document if necessary.
-->
- [ ] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?
## Benchmark
<!--
When the PR has an impact on performance (if you don't know whether the
PR will have an impact on performance, you can submit the PR first, and
if it will have impact on performance, the code reviewer will explain
it), be sure to attach a benchmark data here.
-->
---
.../org/apache/fury/resolver/ClassResolver.java | 108 +++++++--------------
.../apache/fury/resolver/MetaStringResolver.java | 49 ++++++++++
.../apache/fury/resolver/ClassResolverTest.java | 2 +-
3 files changed, 84 insertions(+), 75 deletions(-)
diff --git
a/java/fury-core/src/main/java/org/apache/fury/resolver/ClassResolver.java
b/java/fury-core/src/main/java/org/apache/fury/resolver/ClassResolver.java
index 03c9c684..dc2087d5 100644
--- a/java/fury-core/src/main/java/org/apache/fury/resolver/ClassResolver.java
+++ b/java/fury-core/src/main/java/org/apache/fury/resolver/ClassResolver.java
@@ -19,13 +19,10 @@
package org.apache.fury.resolver;
-import static org.apache.fury.codegen.Expression.Invoke.inlineInvoke;
-import static org.apache.fury.codegen.ExpressionUtils.eq;
import static
org.apache.fury.serializer.CodegenSerializer.loadCodegenSerializer;
import static
org.apache.fury.serializer.CodegenSerializer.loadCompatibleCodegenSerializer;
import static
org.apache.fury.serializer.CodegenSerializer.supportCodegenForJavaSerialization;
import static org.apache.fury.type.TypeUtils.OBJECT_TYPE;
-import static org.apache.fury.type.TypeUtils.PRIMITIVE_SHORT_TYPE;
import static org.apache.fury.type.TypeUtils.getRawType;
import com.google.common.collect.ImmutableMap;
@@ -1227,15 +1224,15 @@ public class ClassResolver {
public void writeClass(MemoryBuffer buffer, ClassInfo classInfo) {
if (classInfo.classId == NO_CLASS_ID) { // no class id provided.
// use classname
- buffer.writeByte(USE_CLASS_VALUE_FLAG);
if (metaContextShareEnabled) {
+ buffer.writeByte(USE_CLASS_VALUE_FLAG);
// FIXME(chaokunyang) Register class but not register serializer can't
be used with
// meta share mode, because no class def are sent to peer.
writeClassWithMetaShare(buffer, classInfo);
} else {
// if it's null, it's a bug.
assert classInfo.packageNameBytes != null;
- metaStringResolver.writeMetaStringBytes(buffer,
classInfo.packageNameBytes);
+ metaStringResolver.writeMetaStringBytesWithFlag(buffer,
classInfo.packageNameBytes);
assert classInfo.classNameBytes != null;
metaStringResolver.writeMetaStringBytes(buffer,
classInfo.classNameBytes);
}
@@ -1423,30 +1420,7 @@ public class ClassResolver {
// Note: Thread safe fot jit thread to call.
public Expression writeClassExpr(
Expression classResolverRef, Expression buffer, Expression classInfo) {
- Expression classId = new Invoke(classInfo, "getClassId",
PRIMITIVE_SHORT_TYPE);
- Expression.ListExpression writeUnregistered =
- new Expression.ListExpression(
- new Invoke(buffer, "writeByte",
Literal.ofByte(USE_CLASS_VALUE_FLAG)));
- if (metaContextShareEnabled) {
- writeUnregistered.add(
- new Invoke(classResolverRef, "writeClassWithMetaShare", buffer,
classInfo));
- } else {
- writeUnregistered.add(
- new Invoke(
- classResolverRef,
- "writeMetaStringBytes",
- buffer,
- inlineInvoke(classInfo, "getPackageNameBytes",
TypeToken.of(MetaStringBytes.class))),
- new Invoke(
- classResolverRef,
- "writeMetaStringBytes",
- buffer,
- inlineInvoke(classInfo, "getClassNameBytes",
TypeToken.of(MetaStringBytes.class))));
- }
- return new Expression.If(
- eq(classId, Literal.ofShort(NO_CLASS_ID)),
- writeUnregistered,
- writeClassExpr(buffer, classId));
+ return new Invoke(classResolverRef, "writeClass", buffer, classInfo);
}
// Note: Thread safe fot jit thread to call.
@@ -1460,11 +1434,6 @@ public class ClassResolver {
return new Invoke(buffer, "writeVarUint32", new Expression.BitShift("<<",
classId, 1));
}
- // Invoked by Fury JIT.
- public void writeMetaStringBytes(MemoryBuffer buffer, MetaStringBytes
byteString) {
- metaStringResolver.writeMetaStringBytes(buffer, byteString);
- }
-
// Note: Thread safe fot jit thread to call.
public Expression skipRegisteredClassExpr(Expression buffer) {
return new Invoke(buffer, "readVarUint32Small14");
@@ -1500,19 +1469,18 @@ public class ClassResolver {
* #readClassInfo(MemoryBuffer, ClassInfoHolder)} should be invoked.
*/
public Class<?> readClassInternal(MemoryBuffer buffer) {
- byte flag = buffer.readByte();
- if (flag == USE_CLASS_VALUE_FLAG) {
+ int header = buffer.readVarUint32Small14();
+ if ((header & 0b1) != 0) {
if (metaContextShareEnabled) {
return readClassWithMetaShare(buffer);
}
- MetaStringBytes packageBytes =
metaStringResolver.readMetaStringBytes(buffer);
+ MetaStringBytes packageBytes =
metaStringResolver.readMetaStringBytesWithFlag(buffer, header);
MetaStringBytes simpleClassNameBytes =
metaStringResolver.readMetaStringBytes(buffer);
final Class<?> cls = loadBytesToClass(packageBytes,
simpleClassNameBytes);
currentReadClass = cls;
return cls;
} else {
- short classId = readClassId(buffer, flag);
- ClassInfo classInfo = registeredId2ClassInfo[classId];
+ ClassInfo classInfo = registeredId2ClassInfo[(short) (header >> 1)];
final Class<?> cls = classInfo.cls;
currentReadClass = cls;
return cls;
@@ -1524,20 +1492,20 @@ public class ClassResolver {
* ClassInfo)} is faster since it use a non-global class info cache.
*/
public ClassInfo readClassInfo(MemoryBuffer buffer) {
- byte flag = buffer.readByte();
- if (flag == USE_CLASS_VALUE_FLAG) {
+ int header = buffer.readVarUint32Small14();
+ if ((header & 0b1) != 0) {
ClassInfo classInfo;
if (metaContextShareEnabled) {
classInfo =
readClassInfoWithMetaShare(buffer,
fury.getSerializationContext().getMetaContext());
} else {
- classInfo = readClassInfoFromBytes(buffer, classInfoCache);
+ classInfo = readClassInfoFromBytes(buffer, classInfoCache, header);
}
classInfoCache = classInfo;
currentReadClass = classInfo.cls;
return classInfo;
} else {
- ClassInfo classInfo = getOrUpdateClassInfo(readClassId(buffer, flag));
+ ClassInfo classInfo = getOrUpdateClassInfo((short) (header >> 1));
currentReadClass = classInfo.cls;
return classInfo;
}
@@ -1549,58 +1517,50 @@ public class ClassResolver {
*/
@CodegenInvoke
public ClassInfo readClassInfo(MemoryBuffer buffer, ClassInfo
classInfoCache) {
- byte flag = buffer.readByte();
- if (flag == USE_CLASS_VALUE_FLAG) {
- if (metaContextShareEnabled) {
- return readClassInfoWithMetaShare(buffer,
fury.getSerializationContext().getMetaContext());
- }
- return readClassInfoFromBytes(buffer, classInfoCache);
+ int header = buffer.readVarUint32Small14();
+ if ((header & 0b1) != 0) {
+ return readClassInfoByCache(buffer, classInfoCache, header);
} else {
- short classId = readClassId(buffer, flag);
- return getClassInfo(classId);
+ return getClassInfo((short) (header >> 1));
}
}
/** Read class info, update classInfoHolder if cache not hit. */
@CodegenInvoke
public ClassInfo readClassInfo(MemoryBuffer buffer, ClassInfoHolder
classInfoHolder) {
- byte flag = buffer.readByte();
- if (flag == USE_CLASS_VALUE_FLAG) {
- if (metaContextShareEnabled) {
- return readClassInfoWithMetaShare(buffer,
fury.getSerializationContext().getMetaContext());
- }
- return readClassInfoFromBytes(buffer, classInfoHolder);
+ int header = buffer.readVarUint32Small14();
+ if ((header & 0b1) != 0) {
+ return readClassInfoFromBytes(buffer, classInfoHolder, header);
} else {
- short classId = readClassId(buffer, flag);
- return getClassInfo(classId);
+ return getClassInfo((short) (header >> 1));
}
}
- private static short readClassId(MemoryBuffer buffer, byte flag) {
- short classId;
- // use classId
- if ((flag & 0x80) != 0) { // class id is written using multiple bytes.
- buffer.increaseReaderIndex(-1);
- classId = (short) buffer.readVarUint32Small14();
- } else {
- classId = (short) (flag & 0x7F);
+ private ClassInfo readClassInfoByCache(
+ MemoryBuffer buffer, ClassInfo classInfoCache, int header) {
+ if (metaContextShareEnabled) {
+ return readClassInfoWithMetaShare(buffer,
fury.getSerializationContext().getMetaContext());
}
- classId >>= 1;
- return classId;
+ return readClassInfoFromBytes(buffer, classInfoCache, header);
}
- private ClassInfo readClassInfoFromBytes(MemoryBuffer buffer,
ClassInfoHolder classInfoHolder) {
- ClassInfo classInfo = readClassInfoFromBytes(buffer,
classInfoHolder.classInfo);
+ private ClassInfo readClassInfoFromBytes(
+ MemoryBuffer buffer, ClassInfoHolder classInfoHolder, int header) {
+ if (metaContextShareEnabled) {
+ return readClassInfoWithMetaShare(buffer,
fury.getSerializationContext().getMetaContext());
+ }
+ ClassInfo classInfo = readClassInfoFromBytes(buffer,
classInfoHolder.classInfo, header);
classInfoHolder.classInfo = classInfo;
return classInfo;
}
- private ClassInfo readClassInfoFromBytes(MemoryBuffer buffer, ClassInfo
classInfoCache) {
+ private ClassInfo readClassInfoFromBytes(
+ MemoryBuffer buffer, ClassInfo classInfoCache, int header) {
MetaStringBytes simpleClassNameBytesCache = classInfoCache.classNameBytes;
if (simpleClassNameBytesCache != null) {
MetaStringBytes packageNameBytesCache = classInfoCache.packageNameBytes;
MetaStringBytes packageBytes =
- metaStringResolver.readMetaStringBytes(buffer,
packageNameBytesCache);
+ metaStringResolver.readMetaStringBytesWithFlag(buffer,
packageNameBytesCache, header);
assert packageNameBytesCache != null;
MetaStringBytes simpleClassNameBytes =
metaStringResolver.readMetaStringBytes(buffer,
simpleClassNameBytesCache);
@@ -1612,7 +1572,7 @@ public class ClassResolver {
return getClassInfo(cls);
}
} else {
- MetaStringBytes packageBytes =
metaStringResolver.readMetaStringBytes(buffer);
+ MetaStringBytes packageBytes =
metaStringResolver.readMetaStringBytesWithFlag(buffer, header);
MetaStringBytes simpleClassNameBytes =
metaStringResolver.readMetaStringBytes(buffer);
Class<?> cls = loadBytesToClass(packageBytes, simpleClassNameBytes);
return getClassInfo(cls);
diff --git
a/java/fury-core/src/main/java/org/apache/fury/resolver/MetaStringResolver.java
b/java/fury-core/src/main/java/org/apache/fury/resolver/MetaStringResolver.java
index 95b786f5..53764086 100644
---
a/java/fury-core/src/main/java/org/apache/fury/resolver/MetaStringResolver.java
+++
b/java/fury-core/src/main/java/org/apache/fury/resolver/MetaStringResolver.java
@@ -78,6 +78,24 @@ public final class MetaStringResolver {
return str;
}
+ public void writeMetaStringBytesWithFlag(MemoryBuffer buffer,
MetaStringBytes byteString) {
+ short id = byteString.dynamicWriteStringId;
+ if (id == MetaStringBytes.DEFAULT_DYNAMIC_WRITE_STRING_ID) {
+ id = dynamicWriteStringId++;
+ byteString.dynamicWriteStringId = id;
+ MetaStringBytes[] dynamicWrittenMetaString = this.dynamicWrittenString;
+ if (dynamicWrittenMetaString.length <= id) {
+ dynamicWrittenMetaString = growWrite(id);
+ }
+ dynamicWrittenMetaString[id] = byteString;
+ buffer.writeVarUint32Small7(byteString.bytes.length << 2 | 0b1);
+ buffer.writeInt64(byteString.hashCode);
+ buffer.writeBytes(byteString.bytes);
+ } else {
+ buffer.writeVarUint32Small7(((id + 1) << 2) | 0b11);
+ }
+ }
+
public void writeMetaStringBytes(MemoryBuffer buffer, MetaStringBytes
byteString) {
short id = byteString.dynamicWriteStringId;
if (id == MetaStringBytes.DEFAULT_DYNAMIC_WRITE_STRING_ID) {
@@ -102,6 +120,37 @@ public final class MetaStringResolver {
return this.dynamicWrittenString = tmp;
}
+ public MetaStringBytes readMetaStringBytesWithFlag(MemoryBuffer buffer, int
header) {
+ int len = header >>> 2;
+ if ((header & 0b10) == 0) {
+ long hashCode = buffer.readInt64();
+ MetaStringBytes byteString = trySkipMetaStringBytes(buffer, len,
hashCode);
+ updateDynamicString(byteString);
+ return byteString;
+ } else {
+ return dynamicReadStringIds[len - 1];
+ }
+ }
+
+ public MetaStringBytes readMetaStringBytesWithFlag(
+ MemoryBuffer buffer, MetaStringBytes cache, int header) {
+ int len = header >>> 2;
+ if ((header & 0b10) == 0) {
+ long hashCode = buffer.readInt64();
+ if (cache.hashCode == hashCode) {
+ // skip byteString data
+ buffer.increaseReaderIndex(len);
+ updateDynamicString(cache);
+ return cache;
+ }
+ MetaStringBytes byteString = trySkipMetaStringBytes(buffer, len,
hashCode);
+ updateDynamicString(byteString);
+ return byteString;
+ } else {
+ return dynamicReadStringIds[len - 1];
+ }
+ }
+
MetaStringBytes readMetaStringBytes(MemoryBuffer buffer) {
int header = buffer.readVarUint32Small7();
int len = header >>> 1;
diff --git
a/java/fury-core/src/test/java/org/apache/fury/resolver/ClassResolverTest.java
b/java/fury-core/src/test/java/org/apache/fury/resolver/ClassResolverTest.java
index fb100842..231d11a6 100644
---
a/java/fury-core/src/test/java/org/apache/fury/resolver/ClassResolverTest.java
+++
b/java/fury-core/src/test/java/org/apache/fury/resolver/ClassResolverTest.java
@@ -221,7 +221,7 @@ public class ClassResolverTest extends FuryTestBase {
classResolver.writeClassInternal(buffer, getClass());
int writerIndex = buffer.writerIndex();
classResolver.writeClassInternal(buffer, getClass());
- Assert.assertEquals(buffer.writerIndex(), writerIndex + 3);
+ Assert.assertEquals(buffer.writerIndex(), writerIndex + 2);
buffer.writerIndex(0);
}
{
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
