perfetto: encode Java event fields before JNI emission The legacy builder crosses JNI for each field. ENCODED writes protobuf fields into one reusable Java buffer and passes them through one emit call. If both modes are active, build both from the same setter calls. Write argument names inline and keep ID slots only for explicit caller interning. Preserve native tracks, string conversion and field order. Enforce the 1 MiB limit before buffer growth and release large buffers after emission. Copying JNI owns the bytes while native emission runs. With the full series on Linux HotSpot, the combined native and Java inline-name changes reduce caller CPU for a four-argument event. Compared with interned names, median ns/event across three JVM runs are 1841 -> 1240 (-32.6%) on v1 and 1622 -> 966 (-40.5%) on v2. These linux_clang_release results cover the two name changes together. Trace output grows from about 61 to 95 bytes/event.
diff --git a/Android.bp b/Android.bp index 4b4d7cb..9940556 100644 --- a/Android.bp +++ b/Android.bp
@@ -1423,6 +1423,9 @@ cc_library_shared { name: "libperfetto_framework_jni", srcs: [ + ":perfetto_base_default_platform", + ":perfetto_include_perfetto_base_base", + ":perfetto_include_perfetto_ext_base_base", ":perfetto_include_perfetto_public_abi_base", ":perfetto_include_perfetto_public_abi_public", ":perfetto_include_perfetto_public_base", @@ -1433,6 +1436,8 @@ ":perfetto_src_android_sdk_nativehelper_nativehelper", ":perfetto_src_android_sdk_perfetto_sdk_for_jni_perfetto_sdk_for_jni", ":perfetto_src_android_sdk_perfetto_sdk_for_jni_perfetto_sdk_for_jni_public", + ":perfetto_src_base_base", + ":perfetto_src_base_check_cpu_optimizations", ], shared_libs: [ "libperfetto_c", @@ -1457,6 +1462,9 @@ shared_libs: [ "liblog", ], + static_libs: [ + "perfetto_flags_c_lib", + ], }, host: { static_libs: [ @@ -1470,6 +1478,9 @@ cc_library_shared { name: "libperfetto_jni", srcs: [ + ":perfetto_base_default_platform", + ":perfetto_include_perfetto_base_base", + ":perfetto_include_perfetto_ext_base_base", ":perfetto_include_perfetto_public_abi_base", ":perfetto_include_perfetto_public_abi_public", ":perfetto_include_perfetto_public_base", @@ -1480,11 +1491,16 @@ ":perfetto_src_android_sdk_nativehelper_nativehelper", ":perfetto_src_android_sdk_perfetto_sdk_for_jni_perfetto_sdk_for_jni", ":perfetto_src_android_sdk_perfetto_sdk_for_jni_perfetto_sdk_for_jni_public", + ":perfetto_src_base_base", + ":perfetto_src_base_check_cpu_optimizations", ], shared_libs: [ "liblog", "libperfetto_c", ], + static_libs: [ + "perfetto_flags_c_lib", + ], defaults: [ "perfetto_defaults", ], @@ -1520,6 +1536,9 @@ cc_library_static { name: "libperfetto_libcore_jni", srcs: [ + ":perfetto_base_default_platform", + ":perfetto_include_perfetto_base_base", + ":perfetto_include_perfetto_ext_base_base", ":perfetto_include_perfetto_public_abi_base", ":perfetto_include_perfetto_public_abi_public", ":perfetto_include_perfetto_public_base", @@ -1530,6 +1549,8 @@ ":perfetto_src_android_sdk_nativehelper_nativehelper", ":perfetto_src_android_sdk_perfetto_sdk_for_jni_perfetto_sdk_for_jni", ":perfetto_src_android_sdk_perfetto_sdk_for_jni_perfetto_sdk_for_jni_public", + ":perfetto_src_base_base", + ":perfetto_src_base_check_cpu_optimizations", ], static_libs: [ "libperfetto_c", @@ -1553,6 +1574,13 @@ visibility: [ "//libcore:__subpackages__", ], + target: { + android: { + static_libs: [ + "perfetto_flags_c_lib", + ], + }, + }, } // GN: //src/perfetto_cmd:perfetto @@ -16261,6 +16289,7 @@ android_library { name: "perfetto_src_android_sdk_java_test_perfetto_trace_test_lib", srcs: [ + "src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoEncodingModeTest.java", "src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoTraceTest.java", ], manifest: "src/android_sdk/java/test/AndroidTestManifest.xml", @@ -24338,6 +24367,7 @@ java_defaults { name: "perfetto_trace_lib_java_defaults", srcs: [ + "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoEncodedEvent.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoNativeLibrary.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoNativeMemoryCleaner.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrace.java", @@ -24364,6 +24394,7 @@ filegroup { name: "perfetto_trace_lib_libcore_java", srcs: [ + "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoEncodedEvent.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoNativeLibrary.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoNativeMemoryCleaner.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrace.java",
diff --git a/BUILD b/BUILD index 2d45bc4..38ec0bf 100644 --- a/BUILD +++ b/BUILD
@@ -7426,6 +7426,7 @@ perfetto_android_library( name = "src_android_sdk_java_main_perfetto_trace_lib", srcs = [ + "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoEncodedEvent.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoNativeLibrary.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoNativeMemoryCleaner.java", "src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrace.java", @@ -7466,6 +7467,7 @@ name = "src_android_sdk_java_test_perfetto_trace_test_lib", testonly = True, srcs = [ + "src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoEncodingModeTest.java", "src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoTraceTest.java", ], manifest = "src/android_sdk/java/test/AndroidTestManifest.xml", @@ -7501,6 +7503,7 @@ ], deps = [ ":libperfetto_c", + ":src_base_base", ], tags = [ "notap",
diff --git a/src/android_sdk/java/main/BUILD.gn b/src/android_sdk/java/main/BUILD.gn index c0ce471..a1ca7b4 100644 --- a/src/android_sdk/java/main/BUILD.gn +++ b/src/android_sdk/java/main/BUILD.gn
@@ -5,6 +5,7 @@ perfetto_android_library("perfetto_trace_lib") { sources = [ + "dev/perfetto/sdk/PerfettoEncodedEvent.java", "dev/perfetto/sdk/PerfettoNativeLibrary.java", "dev/perfetto/sdk/PerfettoNativeMemoryCleaner.java", "dev/perfetto/sdk/PerfettoTrace.java",
diff --git a/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoEncodedEvent.java b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoEncodedEvent.java new file mode 100644 index 0000000..393747d --- /dev/null +++ b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoEncodedEvent.java
@@ -0,0 +1,381 @@ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed 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 dev.perfetto.sdk; + +import java.util.Arrays; +import java.util.Objects; + +/** Encodes protobuf fields; only explicit interning needs a slot trailer. */ +final class PerfettoEncodedEvent { + static final int INITIAL_BUFFER_SIZE = 256; + static final int MAX_KEPT_BUFFER_SIZE = 16 * 1024; + static final int MAX_EVENT_SIZE = 1024 * 1024; + static final int IID_SLOT_SIZE = 10; + static final int SLOT_RECORD_SIZE = 16; + static final int MAX_NESTING_DEPTH = 64; + + private byte[] mBuffer = new byte[INITIAL_BUFFER_SIZE]; + private int mPosition; + private int mFieldsSize; + private int mNameSize; + private int mSlotsOffset; + private int mSlotCount; + private int mTrailerSize; + private boolean mFailed; + private int[] mSlotOffsets = new int[8]; + private int[] mSlotTypes = new int[8]; + private int[] mSlotStringOffsets = new int[8]; + private String[] mSlotStrings = new String[8]; + private int[] mOpenMessages = new int[8]; + private int mOpenCount; + private int mCustomStart = -1; + + void reset() { + Arrays.fill(mSlotStrings, 0, mSlotCount, null); + mPosition = 0; + mFieldsSize = 0; + mNameSize = 0; + mSlotsOffset = 0; + mSlotCount = 0; + mTrailerSize = 0; + mFailed = false; + mOpenCount = 0; + mCustomStart = -1; + } + + void release() { + reset(); + if (mBuffer.length > MAX_KEPT_BUFFER_SIZE) { + mBuffer = new byte[INITIAL_BUFFER_SIZE]; + } + // A single large event must not permanently retain its slot metadata. + if (mSlotOffsets.length > 256) { + mSlotOffsets = new int[8]; + mSlotTypes = new int[8]; + mSlotStringOffsets = new int[8]; + mSlotStrings = new String[8]; + } + if (mOpenMessages.length > 256) + mOpenMessages = new int[8]; + } + + byte[] buffer() { + return mBuffer; + } + int size() { + return mPosition; + } + int fieldsSize() { + return mFieldsSize; + } + int nameSize() { + return mNameSize; + } + int slotsOffset() { + return mSlotsOffset; + } + int slotCount() { + return mSlotCount; + } + + // Keep the legacy JNI's string conversion: one byte per UTF-16 code unit, + // values above 255 become '?', and C-string consumers stop at the first NUL. + // Changing the encoding requires a separate caller-visible migration. + private static int stringSize(String value) { + if (value == null) + return 0; + int zero = value.indexOf('\0'); + return zero < 0 ? value.length() : zero; + } + + private int copyString(String value, int size, int position) { + for (int i = 0; i < size; ++i) { + char c = value.charAt(i); + mBuffer[position++] = (byte) (c <= 255 ? c : '?'); + } + return position; + } + + private void reserve(int count) { + if (mFailed) { + throw new IllegalArgumentException("Encoded event construction already failed"); + } + if (count < 0 || count > MAX_EVENT_SIZE - mPosition - mTrailerSize) { + mFailed = true; + throw new IllegalArgumentException("Encoded event exceeds the 1 MiB transport limit"); + } + ensureCapacity(mPosition + count + mTrailerSize); + } + + // All buffer allocation goes through this method so the Android transport + // can choose non-moving storage without changing the protobuf encoder. + private void ensureCapacity(int required) { + if (required > mBuffer.length) { + int capacity = Math.min(MAX_EVENT_SIZE, Math.max(required, mBuffer.length * 2)); + mBuffer = Arrays.copyOf(mBuffer, capacity); + } + } + + private static int fieldNumber(long id) { + // Android ProtoStream field IDs carry type/count flags in the upper bits. + int number = (int) id; + if (number <= 0 || number > 0x1fffffff) { + throw new IllegalArgumentException("Invalid protobuf field number"); + } + return number; + } + + private void tag(long id, int wireType) { + varint(Integer.toUnsignedLong((fieldNumber(id) << 3) | wireType)); + } + + private void varint(long value) { + int count = 1; + for (long rest = value; (rest & ~0x7fL) != 0; rest >>>= 7) ++count; + reserve(count); + while ((value & ~0x7fL) != 0) { + mBuffer[mPosition++] = (byte) ((value & 0x7f) | 0x80); + value >>>= 7; + } + mBuffer[mPosition++] = (byte) value; + } + + void addVarint(long id, long value) { + tag(id, 0); + varint(value); + } + + void addFixed64(long id, long value) { + tag(id, 1); + reserve(8); + for (int i = 0; i < 8; ++i) { + mBuffer[mPosition++] = (byte) value; + value >>>= 8; + } + } + + void addString(long id, String value) { + int size = stringSize(value); + // Check before writing the tag/length or allocating payload storage. + reserve(size + 10); + tag(id, 2); + varint(size); + mPosition = copyString(value, size, mPosition); + } + + int beginNested(long id) { + if (mOpenCount >= MAX_NESTING_DEPTH) { + mFailed = true; + throw new IllegalArgumentException("Encoded proto nesting exceeds 64 messages"); + } + return beginMessage(id); + } + + private int beginMessage(long id) { + tag(id, 2); + reserve(1); + mBuffer[mPosition++] = 0; + if (mOpenCount == mOpenMessages.length) { + mOpenMessages = Arrays.copyOf(mOpenMessages, mOpenCount * 2); + } + int token = mOpenCount++; + mOpenMessages[token] = mPosition; + return token; + } + + void checkNestedDepth(int expected) { + if (mOpenCount != expected) { + mFailed = true; + throw new IllegalStateException("End nested proto fields before writing to their parent"); + } + } + + void endNested(int token) { + if (mOpenCount == 0 || token != mOpenCount - 1) { + mFailed = true; + throw new IllegalStateException("Nested fields must be closed in order"); + } + int payload = mOpenMessages[--mOpenCount]; + int size = mPosition - payload; + if (size < 128) { + mBuffer[payload - 1] = (byte) size; + return; + } + int extra = 0; + for (int n = size; n >= 128; n >>>= 7) ++extra; + reserve(extra); + System.arraycopy(mBuffer, payload, mBuffer, payload + extra, size); + int position = payload - 1; + int remaining = size; + while (remaining >= 128) { + mBuffer[position++] = (byte) ((remaining & 0x7f) | 0x80); + remaining >>>= 7; + } + mBuffer[position] = (byte) remaining; + mPosition += extra; + for (int i = mSlotCount - 1; i >= 0 && mSlotOffsets[i] >= payload; --i) { + mSlotOffsets[i] += extra; + } + } + + void addInternedString(long id, String value, long type) { + // Existing callers use zero to suppress this optional field. + if ((int) type == 0) + return; + int table = fieldNumber(type); + int size = stringSize(value); + reserve(size + SLOT_RECORD_SIZE + IID_SLOT_SIZE + 5); + if (mSlotCount == mSlotOffsets.length) { + int capacity = mSlotCount * 2; + mSlotOffsets = Arrays.copyOf(mSlotOffsets, capacity); + mSlotTypes = Arrays.copyOf(mSlotTypes, capacity); + mSlotStringOffsets = Arrays.copyOf(mSlotStringOffsets, capacity); + mSlotStrings = Arrays.copyOf(mSlotStrings, capacity); + } + tag(id, 0); + mSlotOffsets[mSlotCount] = mPosition; + mSlotTypes[mSlotCount] = table; + mSlotStrings[mSlotCount++] = value; + // Reserve enough bytes for any uint64 IID. Native emission writes the + // canonical varint and adjusts enclosing message lengths for this sequence. + for (int i = 0; i < IID_SLOT_SIZE - 1; ++i) mBuffer[mPosition++] = (byte) 0x80; + mBuffer[mPosition++] = 0; + mTrailerSize += size + SLOT_RECORD_SIZE; + } + + void beginProto() { + if (mCustomStart < 0) + mCustomStart = mPosition; + } + + void addBuiltinVarint(long id, long value) { + int start = mPosition; + addVarint(id, value); + moveBuiltinBeforeCustom(start); + } + + void addBuiltinFixed64(long id, long value) { + int start = mPosition; + addFixed64(id, value); + moveBuiltinBeforeCustom(start); + } + + void addBuiltinString(long id, String value) { + int start = mPosition; + addString(id, value); + moveBuiltinBeforeCustom(start); + } + + // Legacy writes custom proto fields last, even if a built-in setter follows + // endProto(). Rotate that uncommon late built-in before the custom bytes. + // The usual built-ins-before-proto order needs no movement or second buffer. + private void moveBuiltinBeforeCustom(int start) { + if (mCustomStart < 0) + return; + int size = mPosition - start; + reverseBytes(mCustomStart, start); + reverseBytes(start, mPosition); + reverseBytes(mCustomStart, mPosition); + // Built-ins contain no IID slots. Only the custom slots shift, and their + // order stays the same. + for (int i = 0; i < mSlotCount; ++i) { + if (mSlotOffsets[i] >= mCustomStart) { + mSlotOffsets[i] += size; + } + } + for (int i = 0; i < mOpenCount; ++i) { + if (mOpenMessages[i] >= mCustomStart) + mOpenMessages[i] += size; + } + mCustomStart += size; + } + + private void reverseBytes(int begin, int end) { + while (begin < --end) { + byte value = mBuffer[begin]; + mBuffer[begin++] = mBuffer[end]; + mBuffer[end] = value; + } + } + + private int beginArg(String name) { + Objects.requireNonNull(name); + // A root debug arg may be added while custom nested fields are open. It + // will move before them, so its actual protobuf depth is always one. + int payload = beginMessage(4); // TrackEvent.debug_annotations. + addString(10, name); // DebugAnnotation.name. + return payload; + } + + void addArg(String name, long value) { + int start = mPosition; + int payload = beginArg(name); + addVarint(4, value); + endNested(payload); + moveBuiltinBeforeCustom(start); + } + + void addArg(String name, boolean value) { + int start = mPosition; + int payload = beginArg(name); + addVarint(2, value ? 1 : 0); + endNested(payload); + moveBuiltinBeforeCustom(start); + } + + void addArg(String name, double value) { + int start = mPosition; + int payload = beginArg(name); + addFixed64(5, Double.doubleToRawLongBits(value)); + endNested(payload); + moveBuiltinBeforeCustom(start); + } + + void addArg(String name, String value) { + int start = mPosition; + int payload = beginArg(name); + addString(6, value); + endNested(payload); + moveBuiltinBeforeCustom(start); + } + + void finish(String name) { + while (mOpenCount != 0) endNested(mOpenCount - 1); + mFieldsSize = mPosition; + mNameSize = stringSize(name); + reserve(mNameSize); + mPosition = copyString(name, mNameSize, mPosition); + for (int i = 0; i < mSlotCount; ++i) { + mSlotStringOffsets[i] = mPosition; + mPosition = copyString(mSlotStrings[i], stringSize(mSlotStrings[i]), mPosition); + } + mSlotsOffset = mPosition; + for (int i = 0; i < mSlotCount; ++i) { + putInt(mSlotOffsets[i]); + putInt(mSlotTypes[i]); + putInt(mSlotStringOffsets[i]); + putInt(stringSize(mSlotStrings[i])); + } + } + + private void putInt(int value) { + for (int i = 0; i < 4; ++i) { + mBuffer[mPosition++] = (byte) value; + value >>>= 8; + } + } +}
diff --git a/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrace.java b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrace.java index e1af677..e448e36 100644 --- a/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrace.java +++ b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrace.java
@@ -150,6 +150,7 @@ // Freeze this snapshot in the builder; native emission checks each session. int getEncodingModes() { long ptr = mPtr; + if (getClass() != Category.class && !isEnabled()) return 0; return ptr == 0 ? 0 : native_get_encoding_modes(ptr); }
diff --git a/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventBuilder.java b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventBuilder.java index 6034df9..5bf1269 100644 --- a/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventBuilder.java +++ b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventBuilder.java
@@ -18,6 +18,7 @@ import com.google.errorprone.annotations.CompileTimeConstant; +import java.lang.ref.Reference; import java.util.ArrayList; import java.util.function.Supplier; @@ -41,7 +42,16 @@ private static final int DEFAULT_EXTRA_CACHE_SIZE = 16; private static final int DEFAULT_PENDING_POINTERS_LIST_SIZE = 16; + private static final int ENCODING_LEGACY = 1; + private static final int ENCODING_ENCODED = 2; + private PerfettoTrackEventExtra mExtra; + private PerfettoEncodedEvent mEncoded; + private int mEncodingModes; + private PerfettoPointer mTrack; + private boolean mIsProto; + private boolean mIsNested; + private int mNestedToken; private int mTraceType = -1; private Category mCategory = null; @@ -146,7 +156,8 @@ public static PerfettoTrackEventBuilder newEvent( int traceType, Category category, boolean isDebug) { - if (!category.isEnabled()) { + int modes = category.getEncodingModes(); + if (modes == 0) { return NO_OP_BUILDER; } PerfettoTrackEventBuilder[] pool = sThreadLocalBuilder.get(); @@ -154,11 +165,11 @@ PerfettoTrackEventBuilder builder = pool[i]; if (builder != null) { pool[i] = null; - return builder.initNewEvent(traceType, category, isDebug); + return builder.initNewEvent(traceType, category, isDebug, modes); } } return new PerfettoTrackEventBuilder(/* isCategoryEnabled= */ true, /* parent= */ null) - .initNewEvent(traceType, category, isDebug); + .initNewEvent(traceType, category, isDebug, modes); } private PerfettoTrackEventBuilder(boolean isCategoryEnabled, PerfettoTrackEventBuilder parent) { @@ -183,7 +194,7 @@ readAllCacheFieldsFromParent(parent); } - mExtra = new PerfettoTrackEventExtra(mNativeMemoryCleaner); + // Native extras are allocated lazily when a LEGACY session needs them. } /** Emits the track event. */ @@ -199,14 +210,32 @@ } mIsBuilt = true; - PerfettoTrackEventExtra.native_emit( - mTraceType, mCategory.getPtr(), mEventName, mExtra.getPtr()); - if (mParent == null) { - PerfettoTrackEventBuilder[] pool = sThreadLocalBuilder.get(); - for (int i = 0; i < MAX_POOLED_BUILDERS; i++) { - if (pool[i] == null) { - pool[i] = this; - break; + try { + boolean encoded = hasEncoded(); + if (encoded) mEncoded.finish(mTraceType == 2 || mTraceType == 4 ? "" : mEventName); + PerfettoTrackEventExtra.native_emit_java( + mTraceType, mCategory.getPtr(), mEncodingModes, + hasLegacy() ? mExtra.getPtr() : 0, mTrack == null ? 0 : mTrack.getPtr(), + encoded ? null : mEventName, encoded ? mEncoded.buffer() : null, + encoded ? mEncoded.size() : 0, encoded ? mEncoded.fieldsSize() : 0, + encoded ? mEncoded.nameSize() : 0, encoded ? mEncoded.slotsOffset() : 0, + encoded ? mEncoded.slotCount() : 0); + } finally { + // Native extras and tracks borrow their Java owners' allocations. + Reference.reachabilityFence(mCategory); + Reference.reachabilityFence(mExtra); + Reference.reachabilityFence(mPendingPointers); + Reference.reachabilityFence(mTrack); + if (hasEncoded()) mEncoded.release(); + mPendingPointers.clear(); + mTrack = null; + if (mParent == null) { + PerfettoTrackEventBuilder[] pool = sThreadLocalBuilder.get(); + for (int i = 0; i < MAX_POOLED_BUILDERS; i++) { + if (pool[i] == null) { + pool[i] = this; + break; + } } } } @@ -214,7 +243,7 @@ /** Initialize the builder for a new trace event. */ private PerfettoTrackEventBuilder initNewEvent( - int traceType, Category category, boolean isDebug) { + int traceType, Category category, boolean isDebug, int modes) { if (!mIsCategoryEnabled) { return this; } @@ -225,8 +254,18 @@ mTraceType = traceType; mCategory = category; mEventName = ""; - - mExtra.reset(); + mEncodingModes = modes; + mTrack = null; + mIsProto = false; + mIsNested = false; + if (hasLegacy()) { + if (mExtra == null) mExtra = new PerfettoTrackEventExtra(mNativeMemoryCleaner); + mExtra.reset(); + } + if (hasEncoded()) { + if (mEncoded == null) mEncoded = new PerfettoEncodedEvent(); + mEncoded.reset(); + } mChildBuildersCache.reset(); mObjectsPool.reset(); mPendingPointers.clear(); @@ -236,7 +275,7 @@ } private PerfettoTrackEventBuilder initChildBuilderForProto( - PerfettoTrackEventBuilder parent, FieldContainer fieldContainer) { + PerfettoTrackEventBuilder parent, FieldContainer fieldContainer, boolean nested, int payload) { mIsBuilt = false; mParent = parent; mIsDebug = parent.mIsDebug; @@ -245,6 +284,11 @@ readAllCacheFieldsFromParent(parent); mCurrentContainer = fieldContainer; + mEncodingModes = parent.mEncodingModes; + mEncoded = parent.mEncoded; + mIsProto = true; + mIsNested = nested; + mNestedToken = payload; return this; } @@ -290,13 +334,18 @@ if (mIsDebug) { checkNotBuildingProto(); } - Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); - if (arg == null || !arg.getName().equals(name)) { - arg = new Arg(name, mNativeMemoryCleaner); - mObjectsCache.mArgCache.put(name.hashCode(), arg); + if (hasEncoded()) { + mEncoded.addArg(name, val); } - arg.setValueInt64(val); - addPerfettoPointerToExtra(arg); + if (hasLegacy()) { + Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); + if (arg == null || !arg.getName().equals(name)) { + arg = new Arg(name, mNativeMemoryCleaner); + mObjectsCache.mArgCache.put(name.hashCode(), arg); + } + arg.setValueInt64(val); + addPerfettoPointerToExtra(arg); + } return this; } @@ -308,13 +357,18 @@ if (mIsDebug) { checkNotBuildingProto(); } - Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); - if (arg == null || !arg.getName().equals(name)) { - arg = new Arg(name, mNativeMemoryCleaner); - mObjectsCache.mArgCache.put(name.hashCode(), arg); + if (hasEncoded()) { + mEncoded.addArg(name, val); } - arg.setValueBool(val); - addPerfettoPointerToExtra(arg); + if (hasLegacy()) { + Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); + if (arg == null || !arg.getName().equals(name)) { + arg = new Arg(name, mNativeMemoryCleaner); + mObjectsCache.mArgCache.put(name.hashCode(), arg); + } + arg.setValueBool(val); + addPerfettoPointerToExtra(arg); + } return this; } @@ -326,13 +380,18 @@ if (mIsDebug) { checkNotBuildingProto(); } - Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); - if (arg == null || !arg.getName().equals(name)) { - arg = new Arg(name, mNativeMemoryCleaner); - mObjectsCache.mArgCache.put(name.hashCode(), arg); + if (hasEncoded()) { + mEncoded.addArg(name, val); } - arg.setValueDouble(val); - addPerfettoPointerToExtra(arg); + if (hasLegacy()) { + Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); + if (arg == null || !arg.getName().equals(name)) { + arg = new Arg(name, mNativeMemoryCleaner); + mObjectsCache.mArgCache.put(name.hashCode(), arg); + } + arg.setValueDouble(val); + addPerfettoPointerToExtra(arg); + } return this; } @@ -344,13 +403,18 @@ if (mIsDebug) { checkNotBuildingProto(); } - Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); - if (arg == null || !arg.getName().equals(name)) { - arg = new Arg(name, mNativeMemoryCleaner); - mObjectsCache.mArgCache.put(name.hashCode(), arg); + if (hasEncoded()) { + mEncoded.addArg(name, val); } - arg.setValueString(val); - addPerfettoPointerToExtra(arg); + if (hasLegacy()) { + Arg arg = mObjectsCache.mArgCache.get(name.hashCode()); + if (arg == null || !arg.getName().equals(name)) { + arg = new Arg(name, mNativeMemoryCleaner); + mObjectsCache.mArgCache.put(name.hashCode(), arg); + } + arg.setValueString(val); + addPerfettoPointerToExtra(arg); + } return this; } @@ -367,9 +431,14 @@ if (mIsDebug) { checkNotBuildingProto(); } - Flow flow = mObjectsPool.mFlowPool.get(flowSupplier); - flow.setProcessFlow(id); - addPerfettoPointerToExtra(flow); + if (hasEncoded()) { + mEncoded.addBuiltinFixed64(47, id ^ PerfettoTrace.getProcessTrackUuid()); + } + if (hasLegacy()) { + Flow flow = mObjectsPool.mFlowPool.get(flowSupplier); + flow.setProcessFlow(id); + addPerfettoPointerToExtra(flow); + } return this; } @@ -386,9 +455,14 @@ if (mIsDebug) { checkNotBuildingProto(); } - Flow terminatingFlow = mObjectsPool.mTerminatingFlowPool.get(flowSupplier); - terminatingFlow.setProcessTerminatingFlow(id); - addPerfettoPointerToExtra(terminatingFlow); + if (hasEncoded()) { + mEncoded.addBuiltinFixed64(48, id ^ PerfettoTrace.getProcessTrackUuid()); + } + if (hasLegacy()) { + Flow terminatingFlow = mObjectsPool.mTerminatingFlowPool.get(flowSupplier); + terminatingFlow.setProcessTerminatingFlow(id); + addPerfettoPointerToExtra(terminatingFlow); + } return this; } @@ -409,7 +483,7 @@ // The handle owns its native track (built once, reused for its lifetime), so // there is no builder-side cache to consult -- just hand it over. - addPerfettoPointerToExtra(track.nestedTracks()); + setNativeTrack(track.nestedTracks()); return this; } @@ -450,7 +524,7 @@ track = new NamedTrack(id, name, parentUuid, isNameStatic, mNativeMemoryCleaner); mObjectsCache.mNamedTrackCache.put(key, track); } - addPerfettoPointerToExtra(track); + setNativeTrack(track); return this; } @@ -535,7 +609,7 @@ track = new CounterTrack(name, parentUuid, isNameStatic, mNativeMemoryCleaner); mObjectsCache.mCounterTrackCache.put(key, track); } - addPerfettoPointerToExtra(track); + setNativeTrack(track); return this; } @@ -592,7 +666,7 @@ track = new StateTrack(name, parentUuid, isNameStatic, mNativeMemoryCleaner); mObjectsCache.mStateTrackCache.put(key, track); } - addPerfettoPointerToExtra(track); + setNativeTrack(track); return this; } @@ -644,9 +718,14 @@ if (mIsDebug) { checkNotBuildingProto(); } - Counter counter = mLazyInitObjects.getCounter(); - counter.setValueInt64(val); - addPerfettoPointerToExtra(counter); + if (hasEncoded()) { + if (mTraceType == 4) mEncoded.addBuiltinVarint(30, val); + } + if (hasLegacy()) { + Counter counter = mLazyInitObjects.getCounter(); + counter.setValueInt64(val); + addPerfettoPointerToExtra(counter); + } return this; } @@ -658,9 +737,14 @@ if (mIsDebug) { checkNotBuildingProto(); } - Counter counter = mLazyInitObjects.getCounter(); - counter.setValueDouble(val); - addPerfettoPointerToExtra(counter); + if (hasEncoded()) { + if (mTraceType == 4) mEncoded.addBuiltinFixed64(44, Double.doubleToRawLongBits(val)); + } + if (hasLegacy()) { + Counter counter = mLazyInitObjects.getCounter(); + counter.setValueDouble(val); + addPerfettoPointerToExtra(counter); + } return this; } @@ -676,9 +760,14 @@ if (mIsDebug) { checkNotBuildingProto(); } - CorrelationId correlationId = mLazyInitObjects.getCorrelationId(); - correlationId.setValueInt64(id); - addPerfettoPointerToExtra(correlationId); + if (hasEncoded()) { + mEncoded.addBuiltinVarint(52, id); + } + if (hasLegacy()) { + CorrelationId correlationId = mLazyInitObjects.getCorrelationId(); + correlationId.setValueInt64(id); + addPerfettoPointerToExtra(correlationId); + } return this; } @@ -695,9 +784,14 @@ if (mIsDebug) { checkNotBuildingProto(); } - CorrelationId correlationId = mLazyInitObjects.getCorrelationId(); - correlationId.setValueString(id); - addPerfettoPointerToExtra(correlationId); + if (hasEncoded()) { + mEncoded.addBuiltinString(53, id); + } + if (hasLegacy()) { + CorrelationId correlationId = mLazyInitObjects.getCorrelationId(); + correlationId.setValueString(id); + addPerfettoPointerToExtra(correlationId); + } return this; } @@ -709,9 +803,15 @@ if (mIsDebug) { checkBuildingProto(); } - Field field = mObjectsPool.mFieldPool.get(fieldSupplier); - field.setValueInt64(id, val); - addFieldToContainer(field); + if (hasEncoded()) { + mEncoded.checkNestedDepth(mIsNested ? mNestedToken + 1 : 0); + mEncoded.addVarint(id, val); + } + if (hasLegacy()) { + Field field = mObjectsPool.mFieldPool.get(fieldSupplier); + field.setValueInt64(id, val); + addFieldToContainer(field); + } return this; } @@ -731,9 +831,15 @@ if (mIsDebug) { checkBuildingProto(); } - Field field = mObjectsPool.mFieldPool.get(fieldSupplier); - field.setValueDouble(id, val); - addFieldToContainer(field); + if (hasEncoded()) { + mEncoded.checkNestedDepth(mIsNested ? mNestedToken + 1 : 0); + mEncoded.addFixed64(id, Double.doubleToRawLongBits(val)); + } + if (hasLegacy()) { + Field field = mObjectsPool.mFieldPool.get(fieldSupplier); + field.setValueDouble(id, val); + addFieldToContainer(field); + } return this; } @@ -745,9 +851,15 @@ if (mIsDebug) { checkBuildingProto(); } - Field field = mObjectsPool.mFieldPool.get(fieldSupplier); - field.setValueString(id, val); - addFieldToContainer(field); + if (hasEncoded()) { + mEncoded.checkNestedDepth(mIsNested ? mNestedToken + 1 : 0); + mEncoded.addString(id, val); + } + if (hasLegacy()) { + Field field = mObjectsPool.mFieldPool.get(fieldSupplier); + field.setValueString(id, val); + addFieldToContainer(field); + } return this; } @@ -763,9 +875,15 @@ if (mIsDebug) { checkBuildingProto(); } - Field field = mObjectsPool.mFieldPool.get(fieldSupplier); - field.setValueWithInterning(id, val, internedTypeId); - addFieldToContainer(field); + if (hasEncoded()) { + mEncoded.checkNestedDepth(mIsNested ? mNestedToken + 1 : 0); + mEncoded.addInternedString(id, val, internedTypeId); + } + if (hasLegacy()) { + Field field = mObjectsPool.mFieldPool.get(fieldSupplier); + field.setValueWithInterning(id, val, internedTypeId); + addFieldToContainer(field); + } return this; } @@ -783,12 +901,16 @@ if (mIsDebug) { checkNotBuildingProto(); } - Proto proto = mObjectsPool.mProtoPool.get(protoSupplier); - proto.clearFields(); - addPerfettoPointerToExtra(proto); + if (hasEncoded()) mEncoded.beginProto(); + Proto proto = null; + if (hasLegacy()) { + proto = mObjectsPool.mProtoPool.get(protoSupplier); + proto.clearFields(); + addPerfettoPointerToExtra(proto); + } return mChildBuildersCache .get(perfettoTrackEventBuilderSupplier) - .initChildBuilderForProto(this, proto); + .initChildBuilderForProto(this, proto, false, 0); } /** Ends a proto field. */ @@ -799,12 +921,17 @@ if (mIsDebug) { checkMatchingBeginProto(); } + if (hasEncoded()) mEncoded.checkNestedDepth(0); return mParent; } /** * Begins a nested proto field with field id {@code id}. Fields can be added from this point and * there must be a corresponding {@link #endNested}. + * + * <p>Finish the nested field before adding more proto fields to its parent. The encoded mode + * rejects writes to a parent while its nested field is open. Root event setters may still be + * used while building a nested proto field. Encoded events support up to 64 nested messages. */ public PerfettoTrackEventBuilder beginNested(long id) { if (!mIsCategoryEnabled) { @@ -813,12 +940,20 @@ if (mIsDebug) { checkBuildingProto(); } - FieldNested field = mObjectsPool.mFieldNestedPool.get(fieldNestedSupplier); - field.setId(id); - addFieldToContainer(field); + int payload = 0; + if (hasEncoded()) { + mEncoded.checkNestedDepth(mIsNested ? mNestedToken + 1 : 0); + payload = mEncoded.beginNested(id); + } + FieldNested field = null; + if (hasLegacy()) { + field = mObjectsPool.mFieldNestedPool.get(fieldNestedSupplier); + field.setId(id); + addFieldToContainer(field); + } return mChildBuildersCache .get(perfettoTrackEventBuilderSupplier) - .initChildBuilderForProto(this, field); + .initChildBuilderForProto(this, field, true, payload); } /** Ends a nested proto field. */ @@ -831,9 +966,23 @@ checkMatchingBeginNested(); } + if (hasEncoded()) mEncoded.endNested(mNestedToken); return mParent; } + private boolean hasLegacy() { + return (mEncodingModes & ENCODING_LEGACY) != 0; + } + + private boolean hasEncoded() { + return (mEncodingModes & ENCODING_ENCODED) != 0; + } + + private void setNativeTrack(PerfettoPointer track) { + mTrack = track; + if (hasLegacy()) addPerfettoPointerToExtra(track); + } + private void addFieldToContainer(PerfettoPointer field) { // Keep reference to the java object, `mCurrentContainer` uses a native part of the field // object. @@ -930,16 +1079,15 @@ } private boolean isBuildingTopLevelExtra() { - return mParent == null && mCurrentContainer == null; + return !mIsProto; } private boolean isBuildingProto() { - return (mParent != null && mParent.isBuildingTopLevelExtra()) && mCurrentContainer != null; + return mIsProto && !mIsNested; } private boolean isBuildingNestedProto() { - return (mParent != null && (mParent.isBuildingProtoOrNestedProto())) - && mCurrentContainer != null; + return mIsNested; } private boolean isBuildingProtoOrNestedProto() {
diff --git a/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventExtra.java b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventExtra.java index 6124ccd..70582f8 100644 --- a/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventExtra.java +++ b/src/android_sdk/java/main/dev/perfetto/sdk/PerfettoTrackEventExtra.java
@@ -67,6 +67,11 @@ @FastNative public static native void native_emit(int type, long tag, String name, long ptr); + // Regular JNI: emission can allocate, lock, and ask the tracing service to flush. + static native void native_emit_java( + int type, long category, int modes, long legacyExtra, long track, String legacyName, + byte[] buffer, int size, int fieldsSize, int nameSize, int slotsOffset, int slotCount); + /** Represents a native pointer to a Perfetto C SDK struct. E.g. PerfettoTeHlExtra. */ interface PerfettoPointer { /** Returns the perfetto struct native pointer. */
diff --git a/src/android_sdk/java/test/BUILD.gn b/src/android_sdk/java/test/BUILD.gn index 52da88e..8c21885 100644 --- a/src/android_sdk/java/test/BUILD.gn +++ b/src/android_sdk/java/test/BUILD.gn
@@ -4,7 +4,10 @@ assert(enable_perfetto_android_java_sdk) perfetto_android_library("perfetto_trace_test_lib") { - sources = [ "dev/perfetto/sdk/test/PerfettoTraceTest.java" ] + sources = [ + "dev/perfetto/sdk/test/PerfettoEncodingModeTest.java", + "dev/perfetto/sdk/test/PerfettoTraceTest.java", + ] testonly = true deps = [ "../../../../gn:android_test_common",
diff --git a/src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoEncodingModeTest.java b/src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoEncodingModeTest.java new file mode 100644 index 0000000..120ced3 --- /dev/null +++ b/src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoEncodingModeTest.java
@@ -0,0 +1,511 @@ +/* + * Copyright (C) 2026 The Android Open Source Project + * + * Licensed 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 dev.perfetto.sdk.test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; + +import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.google.protobuf.ByteString; +import com.google.protobuf.UnknownFieldSet; +import dev.perfetto.sdk.PerfettoTrace; +import dev.perfetto.sdk.PerfettoTrace.Category; +import dev.perfetto.sdk.PerfettoTrack; +import dev.perfetto.sdk.PerfettoTrackEventBuilder; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import perfetto.protos.DataSourceConfigOuterClass.DataSourceConfig; +import perfetto.protos.DebugAnnotationOuterClass.DebugAnnotation; +import perfetto.protos.InternedDataOuterClass.InternedData; +import perfetto.protos.TraceConfigOuterClass.TraceConfig; +import perfetto.protos.TraceOuterClass.Trace; +import perfetto.protos.TracePacketOuterClass.TracePacket; +import perfetto.protos.TrackEventConfigOuterClass.TrackEventConfig; +import perfetto.protos.TrackEventConfigOuterClass.TrackEventConfig.JavaEventEncoding; +import perfetto.protos.TrackEventOuterClass.TrackEvent; + +/** Decoded-value comparisons for the Java encoder and per-recording selection. */ +@RunWith(AndroidJUnit4.class) +public class PerfettoEncodingModeTest { + private static final JavaEventEncoding LEGACY = JavaEventEncoding.JAVA_EVENT_ENCODING_LEGACY; + private static final JavaEventEncoding ENCODED = JavaEventEncoding.JAVA_EVENT_ENCODING_ENCODED; + private static final Category CATEGORY = new Category("java_encoding_test"); + private static final String PADDING = "x".repeat(17000); + + @Before + public void setUp() { + PerfettoTrace.registerWithDebugChecks(true); + CATEGORY.register(); + } + + private static TraceConfig config(JavaEventEncoding mode, boolean v2) { + TrackEventConfig te = TrackEventConfig.newBuilder() + .addEnabledCategories(CATEGORY.getName()) + .setDisableIncrementalTimestamps(true) + .setExperimentalJavaEventEncoding(mode) + .build(); + DataSourceConfig ds = + DataSourceConfig.newBuilder() + .setName("track_event") + .setTrackEventConfig(te) + .setExperimentalTracingV2(DataSourceConfig.ExperimentalTracingV2Config.newBuilder() + .setUseV2ProbabilityPercent(v2 ? 100 : 0)) + .build(); + TraceConfig.BufferConfig.Builder buffer = TraceConfig.BufferConfig.newBuilder().setSizeKb(4096); + if (v2) + buffer.setExperimentalMode(TraceConfig.BufferConfig.ExperimentalMode.TRACE_BUFFER_V2); + return TraceConfig.newBuilder() + .addBuffers(buffer) + .addDataSources(TraceConfig.DataSource.newBuilder().setConfig(ds)) + .build(); + } + + private static PerfettoTrace.Session start(JavaEventEncoding mode, boolean v2) { + return new PerfettoTrace.Session(true, config(mode, v2).toByteArray()); + } + + private static void job(PerfettoTrackEventBuilder event, String name) { + // FrameworksBaseTrackEvent.job_scheduler_job (2006), job_name_iid (21), + // FrameworksBaseInternedData.android_job_name (44). Keep the real schema IDs. + event.beginProto() + .beginNested(2006) + .addField(2, PADDING) + .addFieldWithInterning(21, name, 44) + .endNested() + .endProto(); + } + + private static void emitCoverage() { + PerfettoTrackEventBuilder event = + PerfettoTrace.instant(CATEGORY, "all_fields") + .addArg("bool", true) + .addArg("integer", -42L) + .addArg("double", 1.5) + .addArg("string", "value") + .addFlow(7) + .addFlow(8) + .addTerminatingFlow(9) + .usingNamedTrack(42, "named", PerfettoTrace.getProcessTrackUuid()); + job(event, "android-job"); + // The late inline debug name has to move before custom proto fields, + // including the nested IID slot whose length prefix grew twice. + event.addArg("after_proto", 123L) + .setCorrelationId("request") + .beginProto() + .addField(1000, -1L) + .addField(1000, 42L) + .addField(1001, 3.25) + .addField(1002, "proto-string") + .addField(1003, true) + .endProto() + .emit(); + PerfettoTrace.begin(CATEGORY, "slice").emit(); + PerfettoTrace.end(CATEGORY).emit(); + PerfettoTrace.counter(CATEGORY, -4L, "counter").emit(); + PerfettoTrace.counter(CATEGORY, 2.5, "counter").emit(); + PerfettoTrace.state(CATEGORY, "active", "state").emit(); + PerfettoTrace.instant(CATEGORY, "nested_track") + .usingTrack(PerfettoTrack.process("parent").child("child")) + .emit(); + PerfettoTrace.instant(CATEGORY, "dynamic_track") + .usingNamedTrackWithDynamicName(9, "dynamic", PerfettoTrace.getProcessTrackUuid()) + .setCorrelationId(123L) + .emit(); + // Custom fields override built-ins whether the built-in setter came first or last. + PerfettoTrace.counter(CATEGORY, 1L, "counter") + .beginProto() + .addField(30, 7L) + .endProto() + .setCounter(2L) + .emit(); + PerfettoTrace.counter(CATEGORY, 2L, "counter").beginProto().addField(30, 7L).endProto().emit(); + } + + private static final class Sequence { + final Map<Long, ByteString> names = new HashMap<>(); + final Map<Long, ByteString> categories = new HashMap<>(); + final Map<Long, ByteString> debugNames = new HashMap<>(); + final Map<Long, ByteString> jobs = new HashMap<>(); + } + + private static final class Decoded { + final List<TrackEvent> events = new ArrayList<>(); + final List<Long> timestamps = new ArrayList<>(); + final List<Long> jobIids = new ArrayList<>(); + final List<ByteString> jobs = new ArrayList<>(); + } + + private static ByteString resolve(Map<Long, ByteString> table, long iid) { + ByteString value = table.get(iid); + assertNotNull("No definition for IID " + iid, value); + return value; + } + + private static Decoded decode(byte[] bytes) throws Exception { + Decoded result = new Decoded(); + Map<Integer, Sequence> sequences = new HashMap<>(); + for (TracePacket packet : Trace.parseFrom(bytes).getPacketList()) { + int id = packet.getTrustedPacketSequenceId(); + if ((packet.getSequenceFlags() & 1) != 0) + sequences.remove(id); + Sequence sequence = sequences.computeIfAbsent(id, ignored -> new Sequence()); + if (packet.hasInternedData()) { + InternedData data = packet.getInternedData(); + data.getEventNamesList().forEach(v -> sequence.names.put(v.getIid(), v.getNameBytes())); + data.getEventCategoriesList().forEach( + v -> sequence.categories.put(v.getIid(), v.getNameBytes())); + data.getDebugAnnotationNamesList().forEach( + v -> sequence.debugNames.put(v.getIid(), v.getNameBytes())); + for (ByteString job : data.getUnknownFields().getField(44).getLengthDelimitedList()) { + UnknownFieldSet fields = UnknownFieldSet.parseFrom(job); + sequence.jobs.put(fields.getField(1).getVarintList().get(0), + fields.getField(2).getLengthDelimitedList().get(0)); + } + } + if (!packet.hasTrackEvent()) + continue; + TrackEvent event = packet.getTrackEvent(); + TrackEvent.Builder canonical = event.toBuilder(); + if (event.hasNameIid()) { + canonical.clearNameIid().setNameBytes(resolve(sequence.names, event.getNameIid())); + } + canonical.clearCategoryIids(); + for (long iid : event.getCategoryIidsList()) { + canonical.addCategoriesBytes(resolve(sequence.categories, iid)); + } + for (int i = 0; i < event.getDebugAnnotationsCount(); ++i) { + DebugAnnotation arg = event.getDebugAnnotations(i); + if (arg.hasNameIid()) { + canonical.setDebugAnnotations(i, + arg.toBuilder().clearNameIid().setNameBytes( + resolve(sequence.debugNames, arg.getNameIid()))); + } + } + UnknownFieldSet.Field.Builder canonicalJobs = UnknownFieldSet.Field.newBuilder(); + for (ByteString job : event.getUnknownFields().getField(2006).getLengthDelimitedList()) { + UnknownFieldSet fields = UnknownFieldSet.parseFrom(job); + long iid = fields.getField(21).getVarintList().get(0); + ByteString name = resolve(sequence.jobs, iid); + result.jobIids.add(iid); + result.jobs.add(name); + // Compare the resolved value, not a packet-sequence-local numeric ID. + canonicalJobs.addLengthDelimited(fields.toBuilder() + .clearField(21) + .addField(21, UnknownFieldSet.Field.newBuilder().addLengthDelimited(name).build()) + .build() + .toByteString()); + } + if (!event.getUnknownFields().getField(2006).getLengthDelimitedList().isEmpty()) { + canonical.setUnknownFields(event.getUnknownFields() + .toBuilder() + .clearField(2006) + .addField(2006, canonicalJobs.build()) + .build()); + } + result.events.add(canonical.build()); + result.timestamps.add(packet.getTimestamp()); + } + return result; + } + + @Test + public void unregisteredCategoryDropsAnAlreadyBuiltEventInEveryMode() throws Exception { + JavaEventEncoding[][] selections = {{LEGACY}, {ENCODED}, {LEGACY, ENCODED}}; + for (JavaEventEncoding[] modes : selections) { + List<PerfettoTrace.Session> sessions = new ArrayList<>(); + for (JavaEventEncoding mode : modes) sessions.add(start(mode, false)); + PerfettoTrackEventBuilder event = + PerfettoTrace.instant(CATEGORY, "before_unregister").addArg("value", 1L); + CATEGORY.unregister(); + event.emit(); + CATEGORY.register(); + PerfettoTrace.instant(CATEGORY, "after_register").addArg("value", 2L).emit(); + for (PerfettoTrace.Session session : sessions) { + Decoded trace = decode(session.close()); + assertEquals(1, trace.events.size()); + assertEquals("after_register", trace.events.get(0).getName()); + } + } + } + + @Test + public void allFieldsMatchLegacyOnBothWriters() throws Exception { + for (boolean v2 : new boolean[] {false, true}) { + PerfettoTrace.Session legacy = start(LEGACY, v2); + emitCoverage(); + Decoded expected = decode(legacy.close()); + PerfettoTrace.Session encoded = start(ENCODED, v2); + emitCoverage(); + Decoded actual = decode(encoded.close()); + assertEquals(10, actual.events.size()); + assertEquals(expected.events, actual.events); + assertEquals(List.of(ByteString.copyFromUtf8("android-job")), actual.jobs); + assertEquals(7L, actual.events.get(8).getCounterValue()); + assertEquals(7L, actual.events.get(9).getCounterValue()); + } + } + + @Test + public void rootBuiltinsCanBeAddedWhileNestedFieldsAreOpen() throws Exception { + List<TrackEvent> expected = null; + for (JavaEventEncoding mode : new JavaEventEncoding[] {LEGACY, ENCODED}) { + PerfettoTrace.Session session = start(mode, false); + PerfettoTrackEventBuilder root = PerfettoTrace.instant(CATEGORY, "open_nested"); + PerfettoTrackEventBuilder nested = root.beginProto().beginNested(2006); + nested.addField(2, PADDING).addFieldWithInterning(21, "nested-job", 44); + // The inline name grows this debug annotation's length prefix too. + root.addArg("late_root_arg_" + "x".repeat(200), 17L).setCorrelationId("root"); + nested.endNested().endProto().emit(); + Decoded actual = decode(session.close()); + assertEquals(1, actual.events.size()); + if (expected == null) + expected = actual.events; + else + assertEquals(expected, actual.events); + } + } + + @Test + public void mixedModesEmitOnceWithTheSameTimestamp() throws Exception { + for (boolean v2 : new boolean[] {false, true}) { + PerfettoTrace.Session legacy = start(LEGACY, v2); + PerfettoTrace.Session encoded = start(ENCODED, v2); + emitCoverage(); + Decoded a = decode(legacy.close()); + Decoded b = decode(encoded.close()); + assertEquals(10, a.events.size()); + assertEquals(a.events, b.events); + assertEquals(a.timestamps, b.timestamps); + } + } + + @Test + public void encodedNamesAreInlineAndOnlyExplicitFieldsAreInterned() throws Exception { + for (boolean v2 : new boolean[] {false, true}) { + PerfettoTrace.Session legacy = start(LEGACY, v2); + PerfettoTrace.Session encoded = start(ENCODED, v2); + PerfettoTrace.instant(CATEGORY, "ordinary").addArg("key", "value").emit(); + PerfettoTrackEventBuilder explicit = PerfettoTrace.instant(CATEGORY, "explicit"); + job(explicit, "android-job"); + explicit.addArg("late", 42L).emit(); + byte[] legacyBytes = legacy.close(); + byte[] encodedBytes = encoded.close(); + assertEquals(decode(legacyBytes).events, decode(encodedBytes).events); + int events = 0; + int jobs = 0; + for (TracePacket packet : Trace.parseFrom(encodedBytes).getPacketList()) { + InternedData data = packet.getInternedData(); + assertEquals(0, data.getEventNamesCount()); + assertEquals(0, data.getEventCategoriesCount()); + assertEquals(0, data.getDebugAnnotationNamesCount()); + jobs += data.getUnknownFields().getField(44).getLengthDelimitedList().size(); + if (!packet.hasTrackEvent()) continue; + TrackEvent event = packet.getTrackEvent(); + assertFalse(event.hasNameIid()); + assertEquals(events++ == 0 ? "ordinary" : "explicit", event.getName()); + assertEquals(0, event.getCategoryIidsCount()); + assertEquals(List.of(CATEGORY.getName()), event.getCategoriesList()); + assertEquals(1, event.getDebugAnnotationsCount()); + assertTrue(event.getDebugAnnotations(0).hasName()); + assertFalse(event.getDebugAnnotations(0).hasNameIid()); + if (event.getName().equals("ordinary")) assertFalse(packet.hasInternedData()); + } + assertEquals(2, events); + assertEquals(1, jobs); + // The concurrently active legacy recording retains its original wire format. + for (TracePacket packet : Trace.parseFrom(legacyBytes).getPacketList()) { + if (!packet.hasTrackEvent()) continue; + TrackEvent event = packet.getTrackEvent(); + assertTrue(event.hasNameIid()); + assertEquals(1, event.getCategoryIidsCount()); + assertTrue(event.getDebugAnnotations(0).hasNameIid()); + } + } + } + + @Test + public void jobInterningUsesEachSessionsOwnIds() throws Exception { + for (boolean v2 : new boolean[] {false, true}) { + PerfettoTrace.Session a = start(ENCODED, v2); + PerfettoTrackEventBuilder seed = PerfettoTrace.instant(CATEGORY, "seed"); + job(seed, "seed-job"); + seed.emit(); + PerfettoTrace.Session b = start(ENCODED, v2); + PerfettoTrackEventBuilder event = PerfettoTrace.instant(CATEGORY, "common"); + job(event, "shared-job"); + event.emit(); + Decoded first = decode(a.close()); + Decoded second = decode(b.close()); + assertEquals(2, first.events.size()); + assertEquals(1, second.events.size()); + assertEquals(first.events.get(1), second.events.get(0)); + assertNotEquals(first.jobIids.get(1), second.jobIids.get(0)); + assertEquals(ByteString.copyFromUtf8("shared-job"), second.jobs.get(0)); + // A new sequence must emit definitions again despite builder/cache reuse. + PerfettoTrace.Session reset = start(ENCODED, v2); + PerfettoTrackEventBuilder again = PerfettoTrace.instant(CATEGORY, "common"); + job(again, "shared-job"); + again.emit(); + assertEquals(second.events, decode(reset.close()).events); + } + } + + @Test + public void builderModesStayFixedAcrossSessionChanges() throws Exception { + PerfettoTrace.Session a = start(LEGACY, false); + PerfettoTrackEventBuilder old = PerfettoTrace.instant(CATEGORY, "old").addArg("value", 1L); + PerfettoTrace.Session b = start(ENCODED, false); + old.emit(); // ENCODED was not selected when this builder started. + PerfettoTrackEventBuilder mixed = PerfettoTrace.instant(CATEGORY, "mixed").addArg("value", 2L); + Decoded stopped = decode(a.close()); + PerfettoTrace.Session c = start(LEGACY, false); + mixed.emit(); // A later recording of a selected mode may receive it. + Decoded encoded = decode(b.close()); + Decoded lateLegacy = decode(c.close()); + assertEquals(1, stopped.events.size()); + assertEquals("old", stopped.events.get(0).getName()); + assertEquals(1, encoded.events.size()); + assertEquals("mixed", encoded.events.get(0).getName()); + assertEquals(encoded.events, lateLegacy.events); + } + + @Test + public void stringsKeepLegacyBytesInEveryMode() throws Exception { + String[] values = { + null, "", "ascii", "left\0right", "\u00e9", "snow\u2603", "pair\ud83d\ude00", "lone\ud800"}; + List<TrackEvent> expected = null; + for (JavaEventEncoding mode : new JavaEventEncoding[] {LEGACY, ENCODED}) { + PerfettoTrace.Session session = start(mode, false); + for (int i = 0; i < values.length; ++i) { + PerfettoTrackEventBuilder event = PerfettoTrace.instant(CATEGORY, values[i]) + .addArg("key" + i, values[i]) + .setCorrelationId(values[i]); + event.beginProto().addField(1002, values[i]).endProto(); + job(event, values[i]); + event.emit(); + } + Decoded actual = decode(session.close()); + assertEquals(values.length, actual.events.size()); + if (expected == null) + expected = actual.events; + else + assertEquals(expected, actual.events); + } + } + + @Test + public void explicitInterningZeroStillSuppressesOnlyThatField() throws Exception { + for (JavaEventEncoding mode : new JavaEventEncoding[] {LEGACY, ENCODED}) { + PerfettoTrace.Session session = start(mode, false); + PerfettoTrace.instant(CATEGORY, "zero") + .beginProto() + .addFieldWithInterning(1000, "omitted", 0) + .addField(1001, 7L) + .endProto() + .emit(); + Decoded trace = decode(session.close()); + assertEquals(1, trace.events.size()); + assertTrue(trace.events.get(0).getUnknownFields().getField(1000).getVarintList().isEmpty()); + assertEquals( + List.of(7L), trace.events.get(0).getUnknownFields().getField(1001).getVarintList()); + } + } + + @Test + public void oversizedConstructionFailsBeforeEmissionAndBuilderCanBeReused() throws Exception { + PerfettoTrace.Session session = start(ENCODED, false); + PerfettoTrackEventBuilder event = PerfettoTrace.instant(CATEGORY, "oversized"); + assertThrows( + IllegalArgumentException.class, () -> event.addArg("huge", "x".repeat(1024 * 1024))); + assertThrows(IllegalArgumentException.class, event::emit); + PerfettoTrace.instant(CATEGORY, "after_failure").addArg("value", 9L).emit(); + Decoded trace = decode(session.close()); + assertEquals(1, trace.events.size()); + assertEquals("after_failure", trace.events.get(0).getName()); + } + + @Test + public void protoParentWritesDuringNestedFieldsFailWithoutEmission() throws Exception { + PerfettoTrace.Session session = start(ENCODED, false); + PerfettoTrackEventBuilder root = PerfettoTrace.instant(CATEGORY, "invalid_parent_write"); + PerfettoTrackEventBuilder proto = root.beginProto(); + proto.beginNested(1000).addField(1, "nested"); + assertThrows(IllegalStateException.class, () -> proto.addField(1001, "parent")); + assertThrows(IllegalArgumentException.class, root::emit); + PerfettoTrace.instant(CATEGORY, "after_parent_failure").emit(); + Decoded trace = decode(session.close()); + assertEquals(1, trace.events.size()); + assertEquals("after_parent_failure", trace.events.get(0).getName()); + } + + @Test + public void nestedInterningAtTheDepthLimitAndRecoveryBeyondIt() throws Exception { + PerfettoTrace.Session session = start(ENCODED, false); + PerfettoTrackEventBuilder root = PerfettoTrace.instant(CATEGORY, "deep"); + PerfettoTrackEventBuilder nested = root.beginProto(); + for (int i = 0; i < 64; ++i) nested = nested.beginNested(1000); + nested.addFieldWithInterning(21, "deep-name", 44); + root.addArg("root_at_depth_limit", 1L); + for (int i = 0; i < 64; ++i) nested = nested.endNested(); + nested.endProto().emit(); + + PerfettoTrackEventBuilder rejected = PerfettoTrace.instant(CATEGORY, "too_deep"); + PerfettoTrackEventBuilder cursor = rejected.beginProto(); + for (int i = 0; i < 64; ++i) cursor = cursor.beginNested(1000); + PerfettoTrackEventBuilder last = cursor; + assertThrows(IllegalArgumentException.class, () -> last.beginNested(1000)); + assertThrows(IllegalArgumentException.class, rejected::emit); + PerfettoTrace.instant(CATEGORY, "after_depth_failure").emit(); + Decoded trace = decode(session.close()); + assertEquals(2, trace.events.size()); + assertEquals("deep", trace.events.get(0).getName()); + UnknownFieldSet fields = trace.events.get(0).getUnknownFields(); + for (int i = 0; i < 64; ++i) { + fields = UnknownFieldSet.parseFrom(fields.getField(1000).getLengthDelimitedList().get(0)); + } + assertEquals(1, fields.getField(21).getVarintList().size()); + assertTrue(fields.getField(21).getVarintList().get(0) > 0); + assertEquals("after_depth_failure", trace.events.get(1).getName()); + } + + @Test + public void malformedTransportIsRejectedBeforeAnySessionWrites() throws Exception { + PerfettoTrace.Session session = start(ENCODED, false); + Method emit = Class.forName("dev.perfetto.sdk.PerfettoTrackEventExtra") + .getDeclaredMethod("native_emit_java", int.class, long.class, int.class, + long.class, long.class, String.class, byte[].class, int.class, int.class, + int.class, int.class, int.class); + emit.setAccessible(true); + InvocationTargetException error = assertThrows(InvocationTargetException.class, + () + -> emit.invoke(null, 3, CATEGORY.getPtr(), 2, 0L, 0L, null, new byte[] {8}, 1, 1, 0, 1, + 0)); // Truncated varint. + assertTrue(error.getCause() instanceof IllegalArgumentException); + assertTrue(decode(session.close()).events.isEmpty()); + } +}
diff --git a/src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoTraceTest.java b/src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoTraceTest.java index 129c510..8e26ded 100644 --- a/src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoTraceTest.java +++ b/src/android_sdk/java/test/dev/perfetto/sdk/test/PerfettoTraceTest.java
@@ -98,8 +98,13 @@ @Test public void testFreeNativeMemoryWhenJavaObjectGCed() { - TraceConfig traceConfig = getTraceConfig(FOO); - PerfettoTrace.Session session = new PerfettoTrace.Session(true, traceConfig.toByteArray()); + // This test exercises native legacy objects; encoded fields live on the Java heap. + TraceConfig.Builder config = getTraceConfig(FOO).toBuilder(); + DataSourceConfig.Builder ds = config.getDataSources(0).getConfig().toBuilder(); + ds.setTrackEventConfig(ds.getTrackEventConfig().toBuilder().setExperimentalJavaEventEncoding( + TrackEventConfig.JavaEventEncoding.JAVA_EVENT_ENCODING_LEGACY)); + config.setDataSources(0, config.getDataSources(0).toBuilder().setConfig(ds)); + PerfettoTrace.Session session = new PerfettoTrace.Session(true, config.build().toByteArray()); for (int i = 0; i < 600_000; i++) { String eventName = "event_" + i; String nativeStringArgKey = "string_key_" + i; @@ -1068,7 +1073,7 @@ } } - Category disabledFooCategory = new DisabledCategory("DisabledFoo"); + Category disabledFooCategory = new DisabledCategory("DisabledFoo").register(); TraceConfig traceConfig = getTraceConfig(List.of(FOO, "DisabledFoo")); PerfettoTrace.Session session = new PerfettoTrace.Session(true, traceConfig.toByteArray());
diff --git a/src/android_sdk/jni/BUILD.gn b/src/android_sdk/jni/BUILD.gn index ec7da02..42748f2 100644 --- a/src/android_sdk/jni/BUILD.gn +++ b/src/android_sdk/jni/BUILD.gn
@@ -15,6 +15,7 @@ #TODO(ktimofeev): use builtin 'nativehelper' lib when building in AOSP. SOURCE_SET_DEPS = [ "../../../gn:default_deps", + "../../base", "../nativehelper:nativehelper", "../perfetto_sdk_for_jni:perfetto_sdk_for_jni", ]
diff --git a/src/android_sdk/jni/dev_perfetto_sdk_PerfettoTrackEventExtra.cc b/src/android_sdk/jni/dev_perfetto_sdk_PerfettoTrackEventExtra.cc index 64f1045..8ee5e09 100644 --- a/src/android_sdk/jni/dev_perfetto_sdk_PerfettoTrackEventExtra.cc +++ b/src/android_sdk/jni/dev_perfetto_sdk_PerfettoTrackEventExtra.cc
@@ -17,14 +17,18 @@ #include "src/android_sdk/jni/dev_perfetto_sdk_PerfettoTrackEventExtra.h" #include <jni.h> +#include "perfetto/ext/base/small_vector.h" #include "src/android_sdk/jni/macros.h" #include "src/android_sdk/nativehelper/JNIHelp.h" #include "src/android_sdk/nativehelper/scoped_utf_chars.h" #include "src/android_sdk/perfetto_sdk_for_jni/tracing_sdk.h" #include <algorithm> +#include <array> +#include <cstring> #include <list> #include <utility> +#include <vector> namespace perfetto { namespace jni { @@ -626,6 +630,175 @@ StringBuffer::reset(); } +// These are byte offsets in the one Java transport buffer, not instructions. +// Keep the record format in sync with PerfettoEncodedEvent. +constexpr size_t kJavaIidRecordSize = PERFETTO_TE_HL_IID_SLOT_RECORD_SIZE; +constexpr size_t kMaxJavaEventSize = PERFETTO_TE_HL_MAX_ENCODED_EVENT_SIZE; + +// The C ABI consumes a null-terminated list. The Java builder owns the entries, +// but stores no terminator while it is being populated. +class ScopedJavaLegacyExtras { + public: + explicit ScopedJavaLegacyExtras(jlong ptr) + : extra_(toPointer<sdk_for_jni::Extra>(ptr)) { + if (extra_) + extra_->push_extra(nullptr); + } + ~ScopedJavaLegacyExtras() { + if (extra_) + extra_->clear_extras(); + } + ScopedJavaLegacyExtras(const ScopedJavaLegacyExtras&) = delete; + ScopedJavaLegacyExtras& operator=(const ScopedJavaLegacyExtras&) = delete; + + PerfettoTeHlExtra* const* get() const { + return extra_ ? extra_->get() : nullptr; + } + + private: + sdk_for_jni::Extra* extra_; +}; + +static uint32_t ReadJavaUint32(const uint8_t* data) { + return static_cast<uint32_t>(data[0]) | + (static_cast<uint32_t>(data[1]) << 8) | + (static_cast<uint32_t>(data[2]) << 16) | + (static_cast<uint32_t>(data[3]) << 24); +} + +static bool ValidateJavaEventLayout(JNIEnv* env, + jint size, + jint fields_size, + jint name_size, + jint slots_offset, + jint slot_count) { + if (size < 0 || static_cast<size_t>(size) > kMaxJavaEventSize || + fields_size < 0 || fields_size > size || name_size < 0 || + name_size > size - fields_size || + slots_offset < fields_size + name_size || slots_offset > size || + slot_count < 0 || + static_cast<size_t>(slot_count) != + static_cast<size_t>(size - slots_offset) / kJavaIidRecordSize || + static_cast<size_t>(size - slots_offset) % kJavaIidRecordSize != 0) { + jniThrowException(env, "java/lang/IllegalArgumentException", + "Invalid encoded event layout"); + return false; + } + return true; +} + +// The byte storage and Java-owned native handles must live through this call. +// Copying and direct-address transports share this validation and routing. +static void EmitJavaEvent(JNIEnv* env, + jint type, + jlong cat_ptr, + jint modes, + jlong legacy_extra_ptr, + jlong track_ptr, + const uint8_t* bytes, + jint fields_size, + jint name_size, + jint slots_offset, + jint slot_count) { + base::SmallVector<PerfettoTeHlIidSlot, 8> slots; + slots.reserve(static_cast<size_t>(slot_count)); + for (jint i = 0; i < slot_count; ++i) { + const uint8_t* record = + bytes + slots_offset + static_cast<size_t>(i) * kJavaIidRecordSize; + uint32_t string_offset = ReadJavaUint32(record + 8); + uint32_t string_size = ReadJavaUint32(record + 12); + if (string_offset < static_cast<uint32_t>(fields_size + name_size) || + string_offset > static_cast<uint32_t>(slots_offset) || + string_size > static_cast<uint32_t>(slots_offset) - string_offset) { + jniThrowException(env, "java/lang/IllegalArgumentException", + "Invalid encoded interning string"); + return; + } + slots.emplace_back(PerfettoTeHlIidSlot{ReadJavaUint32(record), + ReadJavaUint32(record + 4), + bytes + string_offset, string_size}); + } + PerfettoTeHlEventFields fields{bytes, static_cast<size_t>(fields_size), + slots.data(), slots.size()}; + auto* category = toPointer<sdk_for_jni::Category>(cat_ptr); + ScopedJavaLegacyExtras legacy(legacy_extra_ptr); + if (!category->get()->impl) + return; + PerfettoTeHlExtra* encoded_extras[] = { + toPointer<PerfettoTeHlExtra>(track_ptr), nullptr}; + if (!PerfettoTeHlEmitJavaImpl( + category->get()->impl, type, + type == PERFETTO_TE_TYPE_COUNTER + ? nullptr + : reinterpret_cast<const char*>(bytes + fields_size), + type == PERFETTO_TE_TYPE_COUNTER ? 0 : static_cast<size_t>(name_size), + static_cast<uint32_t>(modes), legacy.get(), &fields, + encoded_extras)) { + jniThrowException(env, "java/lang/IllegalArgumentException", + "Invalid encoded event fields"); + } +} + +static void dev_perfetto_sdk_PerfettoTrackEventExtra_emit_java( + JNIEnv* env, + jclass, + jint type, + jlong cat_ptr, + jint modes, + jlong legacy_extra_ptr, + jlong track_ptr, + jstring legacy_name, + jbyteArray buffer, + jint size, + jint fields_size, + jint name_size, + jint slots_offset, + jint slot_count) { + if ((modes & PERFETTO_TE_JAVA_ENCODING_ENCODED) == 0) { + auto* category = toPointer<sdk_for_jni::Category>(cat_ptr); + ScopedJavaLegacyExtras legacy(legacy_extra_ptr); + if (!category->get()->impl) { + StringBuffer::reset(); + return; + } + const char* name = StringBuffer::utf16_to_ascii(env, legacy_name).data(); + if (!PerfettoTeHlEmitJavaImpl( + category->get()->impl, type, + type == PERFETTO_TE_TYPE_COUNTER ? nullptr : name, + type == PERFETTO_TE_TYPE_COUNTER ? 0 : strlen(name), + static_cast<uint32_t>(modes), legacy.get(), nullptr, nullptr)) { + jniThrowException(env, "java/lang/IllegalArgumentException", + "Invalid Java event modes"); + } + StringBuffer::reset(); + return; + } + if (!ValidateJavaEventLayout(env, size, fields_size, name_size, slots_offset, + slot_count)) { + return; + } + if (!buffer || size > env->GetArrayLength(buffer)) { + jniThrowException(env, "java/lang/IllegalArgumentException", + "Encoded event exceeds its array"); + return; + } + // Never hold a JVM critical-array pin across the tracing call: writers can + // allocate and lock. The portable transport owns a copy until emission ends. + std::array<uint8_t, 1024> local_bytes; + std::vector<uint8_t> large_bytes; + uint8_t* bytes = local_bytes.data(); + if (static_cast<size_t>(size) > local_bytes.size()) { + large_bytes.resize(static_cast<size_t>(size)); + bytes = large_bytes.data(); + } + env->GetByteArrayRegion(buffer, 0, size, reinterpret_cast<jbyte*>(bytes)); + if (env->ExceptionCheck()) + return; + EmitJavaEvent(env, type, cat_ptr, modes, legacy_extra_ptr, track_ptr, bytes, + fields_size, name_size, slots_offset, slot_count); + StringBuffer::reset(); +} + static jlong dev_perfetto_sdk_PerfettoTrackEventExtraProto_init( PERFETTO_JNI_HOST_PARAMS) { return toJLong(new sdk_for_jni::Proto()); @@ -665,7 +838,9 @@ {"native_clear_args", "(J)V", (void*)dev_perfetto_sdk_PerfettoTrackEventExtra_clear_args}, {"native_emit", "(IJLjava/lang/String;J)V", - (void*)dev_perfetto_sdk_PerfettoTrackEventExtra_emit}}; + (void*)dev_perfetto_sdk_PerfettoTrackEventExtra_emit}, + {"native_emit_java", "(IJIJJLjava/lang/String;[BIIIII)V", + (void*)dev_perfetto_sdk_PerfettoTrackEventExtra_emit_java}}; static const JNINativeMethod gProtoMethods[] = { {"native_init", "()J",
diff --git a/src/android_sdk/jni/ravenwood-perfetto-policies.txt b/src/android_sdk/jni/ravenwood-perfetto-policies.txt index dc04e03..491d8ae 100644 --- a/src/android_sdk/jni/ravenwood-perfetto-policies.txt +++ b/src/android_sdk/jni/ravenwood-perfetto-policies.txt
@@ -16,3 +16,5 @@ method native_unregister ignore method native_is_enabled ignore method isEnabled ignore # return false + method native_get_encoding_modes ignore + method getEncodingModes ignore # return 0
diff --git a/tools/run_android_sdk_host_test b/tools/run_android_sdk_host_test index 35ae2d4..ef948aa 100755 --- a/tools/run_android_sdk_host_test +++ b/tools/run_android_sdk_host_test
@@ -34,6 +34,7 @@ import argparse import logging import os +import re import subprocess import sys @@ -95,13 +96,27 @@ def Gn(jdk_home): os.makedirs(OUT_DIR, exist_ok=True) - Run([ - os.path.join(ROOT_DIR, 'tools/gn'), 'gen', OUT_DIR, '--args=' + ' '.join([ - 'is_debug=false', - 'enable_perfetto_android_java_sdk=true', - 'jdk_include_path="%s"' % os.path.join(jdk_home, 'include'), - ]) - ]) + args_path = os.path.join(OUT_DIR, 'args.gn') + content = '' + if os.path.exists(args_path): + with open(args_path) as f: + content = f.read() + else: + content = 'is_debug=false\n' + # Preserve the selected output's compiler, optimization and other settings. + for name, value in [ + ('enable_perfetto_android_java_sdk', 'true'), + ('jdk_include_path', '"%s"' % os.path.join(jdk_home, 'include')), + ]: + line = name + '=' + value + pattern = r'(?m)^\s*' + name + r'\s*=.*$' + if re.search(pattern, content): + content = re.sub(pattern, lambda _: line, content) + else: + content += '\n' + line + '\n' + with open(args_path, 'w') as f: + f.write(content) + Run([os.path.join(ROOT_DIR, 'tools/gn'), 'gen', '--check', OUT_DIR]) def Ninja(): @@ -150,14 +165,15 @@ return jar -def RunTests(jdk_home, jars, sdk_jar, test_jar): +def RunTests(jdk_home, jars, sdk_jar, test_jar, test_classes): env = dict(os.environ, LD_LIBRARY_PATH=OUT_DIR) Run([ - os.path.join(jdk_home, - 'bin/java'), '-Djava.library.path=' + OUT_DIR, '-cp', - Classpath(sdk_jar, test_jar, *jars), 'org.junit.runner.JUnitCore', - TEST_CLASS - ], + os.path.join(jdk_home, 'bin/java'), + '-Djava.library.path=' + OUT_DIR, + '-cp', + Classpath(sdk_jar, test_jar, *jars), + 'org.junit.runner.JUnitCore', + ] + test_classes, env=env) @@ -171,36 +187,52 @@ return jar -def RunBench(jdk_home, sdk_jar, bench_jar, bench_args): +def RunBench(jdk_home, jars, sdk_jar, bench_jar, bench_args): env = dict(os.environ, LD_LIBRARY_PATH=OUT_DIR) Run([os.path.join(jdk_home, 'bin/java')] + BENCH_JVM_FLAGS + [ '-Djava.library.path=' + OUT_DIR, '-cp', - Classpath(sdk_jar, bench_jar), BENCH_CLASS + Classpath(sdk_jar, bench_jar, *jars), BENCH_CLASS ] + bench_args, env=env) def main(): + global OUT_DIR logging.basicConfig(level=logging.INFO, format='%(message)s') parser = argparse.ArgumentParser() parser.add_argument( + '--out', + default=OUT_DIR, + help='GN output directory; existing args.gn settings are preserved.') + parser.add_argument( + '--skip-build', + action='store_true', + help='Reuse the native library and generated Java protos already built.') + parser.add_argument( + '--test-class', + action='append', + help='JUnit class to run; may be repeated. Defaults to PerfettoTraceTest.' + ) + parser.add_argument( '--benchmark', nargs=argparse.REMAINDER, help='Run the benchmark with the arguments that follow, not the tests.') args = parser.parse_args() + OUT_DIR = os.path.abspath(args.out) jdk_home = JdkHome() jars = MavenJars() - Gn(jdk_home) - Ninja() + if not args.skip_build: + Gn(jdk_home) + Ninja() java_protos = os.path.join(OUT_DIR, JAVA_PROTOS_DIR) sdk_jar = CompileSdk(jdk_home, jars, java_protos) if args.benchmark is not None: bench_jar = CompileBench(jdk_home, jars, sdk_jar) - RunBench(jdk_home, sdk_jar, bench_jar, args.benchmark) + RunBench(jdk_home, jars, sdk_jar, bench_jar, args.benchmark) return test_jar = CompileTest(jdk_home, jars, sdk_jar) - RunTests(jdk_home, jars, sdk_jar, test_jar) + RunTests(jdk_home, jars, sdk_jar, test_jar, args.test_class or [TEST_CLASS]) if __name__ == '__main__':