From fed25a8d7fd8989cfcbe0bcf02f47155e5e6b89c Mon Sep 17 00:00:00 2001 From: sanjam panda Date: Wed, 27 May 2026 13:40:06 +0000 Subject: [PATCH 1/2] Fix endian serialization for eventpipe libraries --- src/FastSerialization/FastSerialization.cs | 29 +- .../FastSerialization.csproj | 4 + src/FastSerialization/StreamReaderWriter.cs | 7 +- src/TraceEvent/DynamicTraceEventParser.cs | 14 +- src/TraceEvent/EventPipe/RewindableStream.cs | 36 +- src/TraceEvent/EventPipe/SpanReader.cs | 104 +++++- src/TraceEvent/Parsers/ClrTraceEventParser.cs | 18 + src/TraceEvent/RegisteredTraceEventParser.cs | 4 +- src/TraceEvent/TraceEvent.cs | 37 ++- src/TraceEvent/TraceEvent.csproj | 1 + src/TraceEvent/TraceEventSession.cs | 4 + src/TraceEvent/TraceLog.cs | 307 ++++++++++++------ 12 files changed, 422 insertions(+), 143 deletions(-) diff --git a/src/FastSerialization/FastSerialization.cs b/src/FastSerialization/FastSerialization.cs index bcc2e4c5e..cf3a1cdb7 100644 --- a/src/FastSerialization/FastSerialization.cs +++ b/src/FastSerialization/FastSerialization.cs @@ -9,7 +9,8 @@ using System.Diagnostics; using System.IO; using System.Text; // For StringBuilder. - +using System.Buffers.Binary; +using System.Runtime.InteropServices; // see #Introduction and #SerializerIntroduction namespace FastSerialization { @@ -590,7 +591,6 @@ public Serializer(IStreamWriter writer, IFastSerializable entryObject) Log(""); // Write the header. Write("!FastSerialization.1"); - // Write the main object. This is recursive and does most of the work. Write(entryObject); @@ -605,7 +605,7 @@ public Serializer(IStreamWriter writer, IFastSerializable entryObject) Log(""); if (forwardReferenceDefinitions != null) { - Write(forwardReferenceDefinitions.Count); + Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(forwardReferenceDefinitions.Count))); for (int i = 0; i < forwardReferenceDefinitions.Count; i++) { Debug.Assert(forwardReferenceDefinitions[i] != StreamLabel.Invalid); @@ -688,7 +688,15 @@ public void Write(long value) public void Write(Guid value) { Log(""); - byte[] bytes = value.ToByteArray(); + Span bytes = value.ToByteArray(); + + if (!BitConverter.IsLittleEndian) + { + BinaryPrimitives.WriteInt32LittleEndian(bytes.Slice(0), (MemoryMarshal.Read(bytes.Slice(0,4)))); + BinaryPrimitives.WriteInt16LittleEndian(bytes.Slice(4), (MemoryMarshal.Read(bytes.Slice(4,6)))); + BinaryPrimitives.WriteInt16LittleEndian(bytes.Slice(6), (MemoryMarshal.Read(bytes.Slice(6,8)))); + } + for (int i = 0; i < bytes.Length; i++) { writer.Write(bytes[i]); @@ -815,15 +823,15 @@ public void DefineForwardReference(ForwardReference forwardReference) /// /// Write a byte preceded by a tag that indicates its a short. These should be read with the corresponding TryReadTagged operation /// - public void WriteTagged(short value) { WriteTag(Tags.Int16); Write(value); } + public void WriteTagged(short value) { WriteTag(Tags.Int16); Write(BinaryPrimitives.ReadInt16LittleEndian(BitConverter.GetBytes(value))); } /// /// Write a byte preceded by a tag that indicates its a int. These should be read with the corresponding TryReadTagged operation /// - public void WriteTagged(int value) { WriteTag(Tags.Int32); Write(value); } + public void WriteTagged(int value) { WriteTag(Tags.Int32); Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(value))); } /// /// Write a byte preceded by a tag that indicates its a long. These should be read with the corresponding TryReadTagged operation /// - public void WriteTagged(long value) { WriteTag(Tags.Int64); Write(value); } + public void WriteTagged(long value) { WriteTag(Tags.Int64); Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(value))); } /// /// Write a byte preceded by a tag that indicates its a string. These should be read with the corresponding TryReadTagged operation /// @@ -1591,7 +1599,6 @@ public StreamLabel ResolveForwardReference(ForwardReference reference, bool pres reader.GotoSuffixLabel(); Log(""); StreamLabel forwardRefsLabel = reader.ReadLabel(); - Goto(forwardRefsLabel); int fowardRefCount = reader.ReadInt32(); Log("\r\n"); // We actually don't use the this pointer! We did this for symmetry with Read ForwardReference endRegion = serializer.GetForwardReference(); - serializer.Write(endRegion); // Allow the reader to skip this. + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)endRegion))); // Allow the reader to skip this. toStream(); // Write the deferred data. serializer.DefineForwardReference(endRegion); serializer.Log("\r\n"); @@ -2503,8 +2510,8 @@ internal SerializationType(string fullName, Deserializer deserializer) } void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(version); - serializer.Write(minimumReaderVersion); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(version))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(minimumReaderVersion))); serializer.Write(fullName); } void IFastSerializable.FromStream(Deserializer deserializer) diff --git a/src/FastSerialization/FastSerialization.csproj b/src/FastSerialization/FastSerialization.csproj index 59988c3cf..2dd337be2 100644 --- a/src/FastSerialization/FastSerialization.csproj +++ b/src/FastSerialization/FastSerialization.csproj @@ -29,6 +29,10 @@ + + + + diff --git a/src/FastSerialization/StreamReaderWriter.cs b/src/FastSerialization/StreamReaderWriter.cs index 5c3b8b376..376ac0de9 100644 --- a/src/FastSerialization/StreamReaderWriter.cs +++ b/src/FastSerialization/StreamReaderWriter.cs @@ -8,6 +8,7 @@ using System.Diagnostics; using System.IO; using System.Text; // For StringBuilder. +using System.Buffers.Binary; namespace FastSerialization { @@ -259,7 +260,7 @@ public MemoryStreamWriter(SerializationSettings settings, int initialSize = 64) writeLabel = (value) => { Debug.Assert((long)value <= int.MaxValue); - Write((int)value); + Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)value))); }; } else @@ -267,7 +268,7 @@ public MemoryStreamWriter(SerializationSettings settings, int initialSize = 64) writeLabel = (value) => { Debug.Assert((long)value <= long.MaxValue); - Write((long)value); + Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)value))); }; } @@ -392,7 +393,7 @@ public void Write(string value) } else { - Write(value.Length); + Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(value.Length))); for (int i = 0; i < value.Length; i++) { char c = value[i]; diff --git a/src/TraceEvent/DynamicTraceEventParser.cs b/src/TraceEvent/DynamicTraceEventParser.cs index 7415c4637..044c983e5 100644 --- a/src/TraceEvent/DynamicTraceEventParser.cs +++ b/src/TraceEvent/DynamicTraceEventParser.cs @@ -12,7 +12,7 @@ using System.Text.RegularExpressions; using System.Xml; using Address = System.UInt64; - +using System.Buffers.Binary; namespace Microsoft.Diagnostics.Tracing.Parsers { /// @@ -1830,11 +1830,11 @@ public override string ToString() public void ToStream(Serializer serializer) { - serializer.Write((int)eventID); - serializer.Write((int)task); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventID))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)task))); serializer.Write(taskName); serializer.Write(taskGuid); - serializer.Write((int)opcode); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)opcode))); serializer.Write(opcodeName); serializer.Write(providerGuid); serializer.Write(providerName); @@ -1843,13 +1843,13 @@ public void ToStream(Serializer serializer) serializer.Write(lookupAsWPP); serializer.Write(containsSelfDescribingMetadata); - serializer.Write(payloadNames.Length); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(payloadNames.Length))); foreach (var payloadName in payloadNames) { serializer.Write(payloadName); } - serializer.Write(payloadFetches.Length); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(payloadFetches.Length))); foreach (var payloadFetch in payloadFetches) { payloadFetch.ToStream(serializer); @@ -1983,7 +1983,7 @@ internal class DynamicTraceEventParserState : IFastSerializable void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(providers.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(providers.Count))); foreach (ProviderManifest provider in providers.Values) { serializer.Write(provider); diff --git a/src/TraceEvent/EventPipe/RewindableStream.cs b/src/TraceEvent/EventPipe/RewindableStream.cs index 40431e0e9..4474d77dd 100644 --- a/src/TraceEvent/EventPipe/RewindableStream.cs +++ b/src/TraceEvent/EventPipe/RewindableStream.cs @@ -5,7 +5,7 @@ using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; - +using System.Buffers.Binary; namespace Microsoft.Diagnostics.Tracing.EventPipe { @@ -60,6 +60,40 @@ public T Read() where T : struct { Span buffer = stackalloc byte[Unsafe.SizeOf()]; Read(buffer); + if (!BitConverter.IsLittleEndian) + { + if(typeof(T) == typeof(short)) + { + short val = BinaryPrimitives.ReadInt16LittleEndian(buffer); + return (T)(object)val; + } + else if(typeof(T) == typeof(int)) + { + int val = BinaryPrimitives.ReadInt32LittleEndian(buffer); + return (T)(object)val; + } + else if(typeof(T) == typeof(long)) + { + long val = BinaryPrimitives.ReadInt64LittleEndian(buffer); + return (T)(object)val; + } + else if(typeof(T) == typeof(ushort)) + { + ushort val = BinaryPrimitives.ReadUInt16LittleEndian(buffer); + return (T)(object)val; + } + else if(typeof(T) == typeof(uint)) + { + uint val = BinaryPrimitives.ReadUInt32LittleEndian(buffer); + return (T)(object)val; + } + else if(typeof(T) == typeof(ulong)) + { + ulong val = BinaryPrimitives.ReadUInt64LittleEndian(buffer); + return (T)(object)val; + } + + } return MemoryMarshal.Read(buffer); } diff --git a/src/TraceEvent/EventPipe/SpanReader.cs b/src/TraceEvent/EventPipe/SpanReader.cs index 3a0cf90cf..f8b99e83d 100644 --- a/src/TraceEvent/EventPipe/SpanReader.cs +++ b/src/TraceEvent/EventPipe/SpanReader.cs @@ -2,7 +2,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Text; - +using System.Buffers.Binary; namespace Microsoft.Diagnostics.Tracing.EventPipe { ref struct SpanReader @@ -21,12 +21,90 @@ public SpanReader(ReadOnlySpan buffer, long spanStartStreamOffset) public sbyte ReadInt8() => Read(); public byte ReadUInt8() => Read(); - public short ReadInt16() => Read(); - public ushort ReadUInt16() => Read(); - public int ReadInt32() => Read(); - public uint ReadUInt32() => Read(); - public long ReadInt64() => Read(); - public ulong ReadUInt64() => Read(); + + public short ReadInt16() + { + short val; + if (BinaryPrimitives.TryReadInt16LittleEndian(_buffer, out val)) + { + _buffer = _buffer.Slice(sizeof(short)); + } + else + { + ThrowFormatException(); + } + return val; + } + + public ushort ReadUInt16() + { + ushort val; + if (BinaryPrimitives.TryReadUInt16LittleEndian(_buffer, out val)) + { + _buffer = _buffer.Slice(sizeof(ushort)); + } + else + { + ThrowFormatException(); + } + return val; + } + + public int ReadInt32() + { + int val; + if (BinaryPrimitives.TryReadInt32LittleEndian(_buffer, out val)) + { + _buffer = _buffer.Slice(sizeof(int)); + } + else + { + ThrowFormatException(); + } + return val; + } + + public uint ReadUInt32() + { + uint val; + if (BinaryPrimitives.TryReadUInt32LittleEndian(_buffer, out val)) + { + _buffer = _buffer.Slice(sizeof(uint)); + } + else + { + ThrowFormatException(); + } + return val; + } + + public long ReadInt64() + { + long val; + if (BinaryPrimitives.TryReadInt64LittleEndian(_buffer, out val)) + { + _buffer = _buffer.Slice(sizeof(long)); + } + else + { + ThrowFormatException(); + } + return val; + } + + public ulong ReadUInt64() + { + ulong val; + if (BinaryPrimitives.TryReadUInt64LittleEndian(_buffer, out val)) + { + _buffer = _buffer.Slice(sizeof(ulong)); + } + else + { + ThrowFormatException(); + } + return val; + } public T Read() where T : struct { @@ -156,7 +234,17 @@ public string ReadVarUIntUTF8String() public string ReadNullTerminatedUTF16String() { - ReadOnlySpan charBuffer = MemoryMarshal.Cast(_buffer); + + ReadOnlySpan Buffer = MemoryMarshal.Cast(_buffer); + Span charBuffer = stackalloc char [Buffer.Length]; + Buffer.CopyTo(charBuffer); + if (!BitConverter.IsLittleEndian) + { + for(int ii = 0; ii < charBuffer.Length; ii++) + { + charBuffer[ii] = (char)BinaryPrimitives.ReverseEndianness((ushort)charBuffer[ii]); + } + } for(int i = 0; i < charBuffer.Length; i++) { if (charBuffer[i] == 0) diff --git a/src/TraceEvent/Parsers/ClrTraceEventParser.cs b/src/TraceEvent/Parsers/ClrTraceEventParser.cs index c28710c0f..e8534306c 100644 --- a/src/TraceEvent/Parsers/ClrTraceEventParser.cs +++ b/src/TraceEvent/Parsers/ClrTraceEventParser.cs @@ -4788,12 +4788,30 @@ public sealed class GCBulkNodeTraceData : TraceEvent buffer->TypeID = value->TypeID; buffer->EdgeCount = value->EdgeCount; ret = buffer; + + if (!BitConverter.IsLittleEndian) + { + ret->Address = BinaryPrimitives.ReadUInt32LittleEndian(BitConverter.GetBytes(ret->Address)); + ret->Size = BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes(ret->Size)); + ret->TypeID = BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes(ret->TypeID)); + ret->EdgeCount = BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(ret->EdgeCount)); + } + } else { GCBulkNodeUnsafeNodes* basePtr = (GCBulkNodeUnsafeNodes*)(((byte*)DataStart) + 10); ret = basePtr + arrayIdx; + + if (!BitConverter.IsLittleEndian) + { + ret->Address = BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes(ret->Address)); + ret->Size = BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes(ret->Size)); + ret->TypeID = BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes(ret->TypeID)); + ret->EdgeCount = BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(ret->EdgeCount)); + } } + Debug.Assert((ret->Address & 0xFF00000000000003L) == 0); Debug.Assert((ret->TypeID & 0xFF00000000000001L) == 0); Debug.Assert(ret->Size < 0x80000000L); diff --git a/src/TraceEvent/RegisteredTraceEventParser.cs b/src/TraceEvent/RegisteredTraceEventParser.cs index a971d4c4f..ad815bd7a 100644 --- a/src/TraceEvent/RegisteredTraceEventParser.cs +++ b/src/TraceEvent/RegisteredTraceEventParser.cs @@ -11,7 +11,7 @@ using System.Text; using System.Text.RegularExpressions; using System.Xml; - +using System.Buffers.Binary; namespace Microsoft.Diagnostics.Tracing.Parsers { /// @@ -1567,7 +1567,7 @@ public virtual void ToStream(Serializer serializer) } } - serializer.Write(count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(count))); foreach (var template in m_templates.Values) { if (template != null) diff --git a/src/TraceEvent/TraceEvent.cs b/src/TraceEvent/TraceEvent.cs index 921f3747c..08c08079a 100644 --- a/src/TraceEvent/TraceEvent.cs +++ b/src/TraceEvent/TraceEvent.cs @@ -17,8 +17,9 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Text; -using Address = System.UInt64; +using System.Buffers.Binary; +using Address = System.UInt64; // #Introduction // // Note that TraceEvent lives in a Nuget package. See @@ -3693,7 +3694,7 @@ internal TraceEvent Lookup(TraceEventNativeMethods.EVENT_RECORD* eventRecord) // calculate the hash, and look it up in the table please note that this was hand // inlined, and is replicated in TraceEventDispatcher.Insert - int* guidPtr = (int*)&eventRecord->EventHeader.ProviderId; // This is the taskGuid for Classic events. + int* guidPtr = (int*)&eventRecord->EventHeader.ProviderId; // This is the taskGuid for Classic events. int hash = (*guidPtr + eventID * 9) & templatesLengthMask; for (; ; ) { @@ -4598,15 +4599,15 @@ internal static unsafe float ReadSingle(IntPtr pointer, int offset) } internal static unsafe long ReadInt64(IntPtr pointer, int offset) { - return Unsafe.ReadUnaligned((byte*)pointer.ToPointer() + offset); + return BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(Unsafe.ReadUnaligned((byte*)pointer.ToPointer() + offset))); } internal static unsafe int ReadInt32(IntPtr pointer, int offset) { - return Unsafe.ReadUnaligned((byte*)pointer.ToPointer() + offset); + return BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(Unsafe.ReadUnaligned((byte*)pointer.ToPointer() + offset))); } internal static unsafe short ReadInt16(IntPtr pointer, int offset) { - return *((short*)((byte*)pointer.ToPointer() + offset)); + return BinaryPrimitives.ReadInt16LittleEndian(BitConverter.GetBytes(*((short*)((byte*)pointer.ToPointer() + offset)))); } internal static unsafe IntPtr ReadIntPtr(IntPtr pointer, int offset) { @@ -4649,7 +4650,26 @@ internal static unsafe string ReadUnicodeString(IntPtr pointer, int offset, int // Really we should be able to count on pointers being null terminated. However we have had instances // where this is not true. To avoid scanning the string twice we first check if the last character // in the buffer is a 0 if so, we KNOW we can use the 'fast path' Otherwise we check - byte* ptr = (byte*)pointer; + byte* ptr = (byte*)pointer; + char* charStart = (char*)(ptr + offset); + int maxPos = (bufferLength - offset) / sizeof(char); + int curPos = 0; + if(!BitConverter.IsLittleEndian) + { + char *temp = stackalloc char[maxPos]; + while(curPos < maxPos) + { + char ch = (char)BinaryPrimitives.ReverseEndianness((ushort)charStart[curPos]); + if (ch == 0) + break; + + temp[curPos] = ch; + curPos++; + + } + return new string(temp, 0 curPos); + } + char* charEnd = (char*)(ptr + bufferLength); if (charEnd[-1] == 0) // Is the last character a null? { @@ -4659,14 +4679,11 @@ internal static unsafe string ReadUnicodeString(IntPtr pointer, int offset, int // but who cares as long as it stays in the buffer. // unoptimized path. Carefully count characters and create a string up to the null. - char* charStart = (char*)(ptr + offset); - int maxPos = (bufferLength - offset) / sizeof(char); - int curPos = 0; while (curPos < maxPos && charStart[curPos] != 0) { curPos++; } - // CurPos now points at the end (either buffer end or null terminator, make just the right sized string. + // CurPos now points at the end (either buffer end or null terminator, make just the right sized string. return new string(charStart, 0, curPos); } internal static unsafe string ReadUTF8String(IntPtr pointer, int offset, int bufferLength) diff --git a/src/TraceEvent/TraceEvent.csproj b/src/TraceEvent/TraceEvent.csproj index c8abab7f6..259ea4a2f 100644 --- a/src/TraceEvent/TraceEvent.csproj +++ b/src/TraceEvent/TraceEvent.csproj @@ -77,6 +77,7 @@ + diff --git a/src/TraceEvent/TraceEventSession.cs b/src/TraceEvent/TraceEventSession.cs index 3e1cb624b..2d17130da 100644 --- a/src/TraceEvent/TraceEventSession.cs +++ b/src/TraceEvent/TraceEventSession.cs @@ -3112,6 +3112,10 @@ public static string GetProviderName(Guid providerGuid) public static unsafe bool MaybeAnEventSource(Guid providerGuid) { byte octet7 = ((byte*)(&providerGuid))[7]; + if (!BitConverter.IsLittleEndian) + { + octet7 = ((byte*)(&providerGuid))[6]; + } if ((octet7 & 0xF0) == 0x50) { return true; diff --git a/src/TraceEvent/TraceLog.cs b/src/TraceEvent/TraceLog.cs index f397c03bb..28aada15d 100644 --- a/src/TraceEvent/TraceLog.cs +++ b/src/TraceEvent/TraceLog.cs @@ -23,6 +23,7 @@ using Microsoft.Diagnostics.Tracing.Utilities; using Microsoft.Diagnostics.Utilities; using System; +using System.Buffers.Binary; using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.Tracing; @@ -34,8 +35,8 @@ using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; -using Address = System.UInt64; +using Address = System.UInt64; namespace Microsoft.Diagnostics.Tracing.Etlx { @@ -2343,8 +2344,22 @@ private unsafe void CopyRawEvents(TraceEventDispatcher rawEvents, IStreamWriter } unsafe { - Debug.Assert(data.eventRecord->EventHeader.TimeStamp < long.MaxValue); - WriteBlob((IntPtr)data.eventRecord, writer, headerSize); + if (!BitConverter.IsLittleEndian) + { + Span buffer = stackalloc byte[headerSize]; + new Span(data.eventRecord, headerSize).CopyTo(buffer); + SwapEventRecordEndianness(buffer); + fixed (byte* bufferPtr = buffer) + { + WriteBlob((IntPtr)bufferPtr, writer, headerSize); + } + } + else + { + Debug.Assert(data.eventRecord->EventHeader.TimeStamp < long.MaxValue); + WriteBlob((IntPtr)data.eventRecord, writer, headerSize); + } + WriteBlob(data.userData, writer, (data.EventDataLength + 3 & ~3)); } numberOnPage++; @@ -3264,6 +3279,7 @@ internal unsafe bool ProcessExtendedData(TraceEvent data, ushort extendedDataCou if (extendedData[i].ExtType == TraceEventNativeMethods.EVENT_HEADER_EXT_TYPE_STACK_TRACE64 || extendedData[i].ExtType == TraceEventNativeMethods.EVENT_HEADER_EXT_TYPE_STACK_TRACE32) { + int pointerSize = (extendedData[i].ExtType == TraceEventNativeMethods.EVENT_HEADER_EXT_TYPE_STACK_TRACE64) ? 8 : 4; var stackRecord = (TraceEventNativeMethods.EVENT_EXTENDED_ITEM_STACK_TRACE64*)extendedData[i].DataPtr; // TODO Debug.Assert(stackRecord->MatchId == 0); @@ -3463,6 +3479,63 @@ private static unsafe void WriteBlob(IntPtr source, IStreamWriter writer, int by } } + private static void SwapEventRecordEndianness(Span buffer) + { + int offset = 0; + buffer.Slice(offset, 2).Reverse(); + offset += 2; // Size (UInt16) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // HeaderType (UInt16) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // Flags (UInt16) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // EventProperty (UInt16) + buffer.Slice(offset, 4).Reverse(); + offset += 4; // ThreadId (Int32) + buffer.Slice(offset, 4).Reverse(); + offset += 4; // ProcessId (Int32) + buffer.Slice(offset, 8).Reverse(); + offset += 8; // TimeStamp (Int64) + + // ProviderId GUID (16 bytes) - swap first 3 components only + buffer.Slice(offset, 4).Reverse(); + offset += 4; // Data1 (Int32) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // Data2 (Int16) + buffer.Slice(offset, 2).Reverse(); + offset += 10; // Data3 (Int16) + Data4 (8 bytes) - unchanged + + buffer.Slice(offset, 2).Reverse(); + offset += 6; // Id (UInt16) + Version, Channel, Level, Opcode (4 single bytes) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // Task (UInt16) + buffer.Slice(offset, 8).Reverse(); + offset += 8; // Keyword (UInt64) + buffer.Slice(offset, 4).Reverse(); + offset += 4; // KernelTime (UInt32) + buffer.Slice(offset, 4).Reverse(); + offset += 4; // UserTime (UInt32) + + // ActivityId GUID (16 bytes) - swap first 3 components only + buffer.Slice(offset, 4).Reverse(); + offset += 4; // Data1 (Int32) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // Data2 (Int16) + buffer.Slice(offset, 2).Reverse(); + offset += 12; // Data3 (Int16) + Data4 (8 bytes) - unchanged + ProcessorNumber, Alignment (2 single bytes) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // LoggerId (UInt16) + + buffer.Slice(offset, 2).Reverse(); + offset += 2; // ExtendedDataCount (UInt16) + buffer.Slice(offset, 2).Reverse(); + offset += 2; // UserDataLength (UInt16) + buffer.Slice(offset, 8).Reverse(); + offset += 8; // ExtendedData (pointer - UInt64) + buffer.Slice(offset, 8).Reverse(); + offset += 8; // UserData (pointer - UInt64) + } + // [Conditional("DEBUG")] internal void DebugWarn(bool condition, string message, TraceEvent data) { @@ -3588,7 +3661,7 @@ internal unsafe void SeekToTimeOnPage(PinnedStreamReader reader, long timeQPC, i Debug.Assert(ptr->EventHeader.Level <= 6); Debug.Assert(ptr->EventHeader.Version <= 10); - long eventTimeQPC = ptr->EventHeader.TimeStamp; + long eventTimeQPC = BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(ptr->EventHeader.TimeStamp)); Debug.Assert(sessionStartTimeQPC <= eventTimeQPC && eventTimeQPC < DateTime.Now.Ticks || eventTimeQPC == long.MaxValue); if (eventTimeQPC >= timeQPC) @@ -3847,7 +3920,7 @@ void IFastSerializable.ToStream(Serializer serializer) { if (i == 2) { - serializer.Write(long.MaxValue); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(long.MaxValue))); } else { @@ -3862,20 +3935,20 @@ void IFastSerializable.ToStream(Serializer serializer) }); serializer.Log(""); - serializer.Write(_syncTimeUTC.ToFileTimeUtc()); - serializer.Write(pointerSize); - serializer.Write(numberOfProcessors); - serializer.Write(cpuSpeedMHz); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(_syncTimeUTC.ToFileTimeUtc()))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(pointerSize))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(numberOfProcessors))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cpuSpeedMHz))); serializer.Write((byte)osVersion.Major); serializer.Write((byte)osVersion.Minor); serializer.Write((byte)osVersion.MajorRevision); serializer.Write((byte)osVersion.MinorRevision); - serializer.Write(QPCFreq); - serializer.Write(sessionStartTimeQPC); - serializer.Write(sessionEndTimeQPC); - serializer.Write(eventsLost); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(QPCFreq))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(sessionStartTimeQPC))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(sessionEndTimeQPC))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsLost))); serializer.Write(machineName); - serializer.Write(memorySizeMeg); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(memorySizeMeg))); serializer.Write(processes); serializer.Write(threads); @@ -3885,29 +3958,29 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(moduleFiles); serializer.Log("\r\n"); - serializer.Write(eventPages.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventPages.Count))); for (int i = 0; i < eventPages.Count; i++) { - serializer.Write(eventPages[i].TimeQPC); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(eventPages[i].TimeQPC))); serializer.Write(eventPages[i].Position); } - serializer.Write(eventPages.Count); // redundant as a checksum + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventPages.Count))); // redundant as a checksum serializer.Log("\r\n"); - serializer.Write(eventCount); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventCount))); serializer.Log(""); lazyEventsToStacks.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(eventsToStacks.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToStacks.Count))); for (int i = 0; i < eventsToStacks.Count; i++) { EventsToStackIndex eventToStack = eventsToStacks[i]; Debug.Assert(i == 0 || eventsToStacks[i - 1].EventIndex <= eventsToStacks[i].EventIndex, "event list not sorted"); - serializer.Write((int)eventToStack.EventIndex); - serializer.Write((int)eventToStack.CallStackIndex); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.EventIndex))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.CallStackIndex))); } - serializer.Write(eventsToStacks.Count); // Redundant as a checksum + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToStacks.Count))); // Redundant as a checksum serializer.Log("\r\n"); }); @@ -3915,15 +3988,15 @@ void IFastSerializable.ToStream(Serializer serializer) lazyEventsToStacks.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(cswitchBlockingEventsToStacks.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cswitchBlockingEventsToStacks.Count))); for (int i = 0; i < cswitchBlockingEventsToStacks.Count; i++) { EventsToStackIndex eventToStack = cswitchBlockingEventsToStacks[i]; Debug.Assert(i == 0 || cswitchBlockingEventsToStacks[i - 1].EventIndex <= cswitchBlockingEventsToStacks[i].EventIndex, "event list not sorted"); - serializer.Write((int)eventToStack.EventIndex); - serializer.Write((int)eventToStack.CallStackIndex); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.EventIndex))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.CallStackIndex))); } - serializer.Write(cswitchBlockingEventsToStacks.Count); // Redundant as a checksum + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cswitchBlockingEventsToStacks.Count))); // Redundant as a checksum serializer.Log("\r\n"); }); @@ -3931,44 +4004,44 @@ void IFastSerializable.ToStream(Serializer serializer) lazyEventsToCodeAddresses.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(eventsToCodeAddresses.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToCodeAddresses.Count))); foreach (EventsToCodeAddressIndex eventsToCodeAddress in eventsToCodeAddresses) { - serializer.Write((int)eventsToCodeAddress.EventIndex); - serializer.Write((long)eventsToCodeAddress.Address); - serializer.Write((int)eventsToCodeAddress.CodeAddressIndex); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventsToCodeAddress.EventIndex))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)eventsToCodeAddress.Address))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventsToCodeAddress.CodeAddressIndex))); } - serializer.Write(eventsToCodeAddresses.Count); // Redundant as a checksum + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToCodeAddresses.Count))); // Redundant as a checksum serializer.Log("\r\n"); }); serializer.Log("\r\n"); - serializer.Write(userData.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(userData.Count))); foreach (KeyValuePair pair in UserData) { serializer.Write(pair.Key); IFastSerializable asFastSerializable = (IFastSerializable)pair.Value; serializer.Write(asFastSerializable); } - serializer.Write(userData.Count); // Redundant as a checksum + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(userData.Count))); // Redundant as a checksum serializer.Log("\r\n"); - serializer.Write(sampleProfileInterval100ns); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(sampleProfileInterval100ns))); serializer.Write(osName); serializer.Write(osBuild); - serializer.Write(bootTime100ns); - serializer.Write(utcOffsetMinutes ?? int.MinValue); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(bootTime100ns))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(utcOffsetMinutes ?? int.MinValue))); serializer.Write(hasPdbInfo); serializer.Log("\r\n"); - serializer.Write(relatedActivityIDs.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(relatedActivityIDs.Count))); for (int i = 0; i < relatedActivityIDs.Count; i++) { serializer.Write(relatedActivityIDs[i]); } serializer.Log("\r\n"); - serializer.Write(containerIDs.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(containerIDs.Count))); for (int i = 0; i < containerIDs.Count; i++) { serializer.Write(containerIDs[i]); @@ -3977,7 +4050,7 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Log("\r\n"); serializer.Write(truncated); - serializer.Write((int)firstTimeInversion); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)firstTimeInversion))); } void IFastSerializable.FromStream(Deserializer deserializer) { @@ -4799,7 +4872,7 @@ internal TraceEventCounts GetEventCounts(TraceEvent data) void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(m_log); - serializer.Write(m_counts.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(m_counts.Count))); foreach (var counts in m_counts.Values) { serializer.Write(counts); @@ -4885,7 +4958,7 @@ public override int GetHashCode() public void Serialize(Serializer serializer) { serializer.Write(m_providerGuid); - serializer.Write((int)m_eventId); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)m_eventId))); serializer.Write(m_classicProvider); } } @@ -5129,9 +5202,9 @@ void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(m_stats); m_key.Serialize(serializer); - serializer.Write(m_count); - serializer.Write(m_stackCount); - serializer.Write(m_eventDataLenTotal); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(m_count))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(m_stackCount))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(m_eventDataLenTotal))); } void IFastSerializable.FromStream(Deserializer deserializer) { @@ -5329,6 +5402,39 @@ public void Reset() protected unsafe TraceEvent GetNext() { TraceEventNativeMethods.EVENT_RECORD* ptr = (TraceEventNativeMethods.EVENT_RECORD*)reader.GetPointer(TraceLog.headerSize); + if (!BitConverter.IsLittleEndian) + { + ptr->EventHeader.Size = BinaryPrimitives.ReadUInt16LittleEndian(BitConverter.GetBytes(ptr->EventHeader.Size)); + ptr->EventHeader.HeaderType = BinaryPrimitives.ReadUInt16LittleEndian(BitConverter.GetBytes(ptr->EventHeader.HeaderType)); + ptr->EventHeader.Flags = BinaryPrimitives.ReadUInt16LittleEndian(BitConverter.GetBytes(ptr->EventHeader.Flags)); + ptr->EventHeader.EventProperty = BinaryPrimitives.ReadUInt16LittleEndian(BitConverter.GetBytes(ptr->EventHeader.EventProperty)); + ptr->EventHeader.ThreadId = BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(ptr->EventHeader.ThreadId)); + ptr->EventHeader.ProcessId = BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(ptr->EventHeader.ProcessId)); + ptr->EventHeader.TimeStamp = BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(ptr->EventHeader.TimeStamp)); + ptr->EventHeader.Id = BinaryPrimitives.ReadUInt16LittleEndian(BitConverter.GetBytes(ptr->EventHeader.Id)); + ptr->EventHeader.Task = BinaryPrimitives.ReadUInt16LittleEndian(BitConverter.GetBytes(ptr->EventHeader.Task)); + ptr->EventHeader.Keyword = BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes(ptr->EventHeader.Keyword)); + ptr->EventHeader.KernelTime = BinaryPrimitives.ReadUInt32LittleEndian(BitConverter.GetBytes(ptr->EventHeader.KernelTime)); + ptr->EventHeader.UserTime = BinaryPrimitives.ReadUInt32LittleEndian(BitConverter.GetBytes(ptr->EventHeader.UserTime)); + + Span guidarr = stackalloc byte[16]; + + guidarr = ptr->EventHeader.ProviderId.ToByteArray(); + BinaryPrimitives.WriteInt32LittleEndian(guidarr.Slice(0), (MemoryMarshal.Read(guidarr.Slice(0,4)))); + BinaryPrimitives.WriteInt16LittleEndian(guidarr.Slice(4), (MemoryMarshal.Read(guidarr.Slice(4,6)))); + BinaryPrimitives.WriteInt16LittleEndian(guidarr.Slice(6), (MemoryMarshal.Read(guidarr.Slice(6,8)))); + ptr->EventHeader.ProviderId = new Guid(guidarr.ToArray()); + + guidarr = ptr->EventHeader.ActivityId.ToByteArray(); + BinaryPrimitives.WriteInt32LittleEndian(guidarr.Slice(0), (MemoryMarshal.Read(guidarr.Slice(0,4)))); + BinaryPrimitives.WriteInt16LittleEndian(guidarr.Slice(4), (MemoryMarshal.Read(guidarr.Slice(4,6)))); + BinaryPrimitives.WriteInt16LittleEndian(guidarr.Slice(6), (MemoryMarshal.Read(guidarr.Slice(6,8)))); + ptr->EventHeader.ActivityId = new Guid(guidarr.ToArray()); + + ptr->UserDataLength = BinaryPrimitives.ReadUInt16LittleEndian(BitConverter.GetBytes(ptr->UserDataLength)); + ptr->UserData = (IntPtr)BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes((ulong)ptr->UserData)); + ptr->UserContext = (IntPtr)BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes((ulong)ptr->UserContext)); + } TraceEvent ret = lookup.Lookup(ptr); // We use the first item in the linked list in 'ret'. This should always be the 'best' way of decoding @@ -5709,7 +5815,7 @@ void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(log); serializer.Log("\r\n"); - serializer.Write(processes.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(processes.Count))); for (int i = 0; i < processes.Count; i++) { serializer.Write(processes[i]); @@ -5718,7 +5824,7 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Log("\r\n"); serializer.Log("\r\n"); - serializer.Write(processesByPID.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(processesByPID.Count))); for (int i = 0; i < processesByPID.Count; i++) { serializer.Write(processesByPID[i]); @@ -6115,24 +6221,24 @@ internal TraceProcess(int processID, TraceLog log, ProcessIndex processIndex) void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(processID); - serializer.Write((int)processIndex); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(processID))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)processIndex))); serializer.Write(log); serializer.Write(commandLine); serializer.Write(imageFileName); - serializer.Write(firstEventSeenQPC); - serializer.Write(startTimeQPC); - serializer.Write(endTimeQPC); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(firstEventSeenQPC))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(startTimeQPC))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(endTimeQPC))); serializer.Write(exitStatus.HasValue); if (exitStatus.HasValue) { - serializer.Write(exitStatus.Value); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(exitStatus.Value))); } - serializer.Write(parentID); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(parentID))); serializer.Write(parent); serializer.Write(loadedModules); - serializer.Write(cpuSamples); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cpuSamples))); serializer.Write(loadedAModuleHigh); serializer.Write(anyModuleLoaded); } @@ -6577,7 +6683,7 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(log); serializer.Log("\r\n"); - serializer.Write(threads.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(threads.Count))); for (int i = 0; i < threads.Count; i++) { serializer.Write(threads[i]); @@ -6771,20 +6877,20 @@ internal TraceThread(int threadID, TraceProcess process, ThreadIndex threadIndex void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(threadID); - serializer.Write((int)threadIndex); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(threadID))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)threadIndex))); serializer.Write(process); - serializer.Write(startTimeQPC); - serializer.Write(endTimeQPC); - serializer.Write(cpuSamples); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(startTimeQPC))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(endTimeQPC))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cpuSamples))); serializer.Write(threadInfo); - serializer.Write((long)userStackBase); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)userStackBase))); - serializer.Write(activityIds.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(activityIds.Count))); serializer.Log("\r\n"); foreach (ActivityIndex entry in activityIds) { - serializer.Write((int)entry); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)entry))); } serializer.Log("\r\n"); @@ -7385,7 +7491,7 @@ void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(process); serializer.Log("\r\n"); - serializer.Write(modules.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(modules.Count))); for (int i = 0; i < modules.Count; i++) { serializer.Write(modules[i]); @@ -7557,12 +7663,12 @@ internal TraceLoadedModule(TraceProcess process, TraceModuleFile moduleFile, lon void IFastSerializable.ToStream(Serializer serializer) { ToStream(serializer); } internal void ToStream(Serializer serializer) { - serializer.Write(loadTimeQPC); - serializer.Write(unloadTimeQPC); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(loadTimeQPC))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(unloadTimeQPC))); serializer.Write(managedModule); serializer.Write(process); serializer.Write(moduleFile); - serializer.Write((long)key); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)key))); serializer.Write(overlaps); } /// @@ -7657,9 +7763,9 @@ internal void InitializeNativeModuleIsReadyToRun() void IFastSerializable.ToStream(Serializer serializer) { base.ToStream(serializer); - serializer.Write(assemblyID); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(assemblyID))); serializer.Write(nativeModule); - serializer.Write((int)flags); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)flags))); } void IFastSerializable.FromStream(Deserializer deserializer) { @@ -7853,12 +7959,11 @@ internal unsafe CallStackIndex GetStackIndexForStackEvent(void* addresses, GetStackIndexForStackEvent64((ulong*)addresses, addressCount, thread.Process, start) : GetStackIndexForStackEvent32((uint*)addresses, addressCount, thread.Process, start); } - private unsafe CallStackIndex GetStackIndexForStackEvent32(uint* addresses, int addressCount, TraceProcess process, CallStackIndex start) { for (var it = &addresses[addressCount]; it-- != addresses;) { - CodeAddressIndex codeAddress = codeAddresses.GetOrCreateCodeAddressIndex(process, *it); + CodeAddressIndex codeAddress = codeAddresses.GetOrCreateCodeAddressIndex(process, BinaryPrimitives.ReadUInt32LittleEndian(BitConverter.GetBytes((uint)(*it)))); start = InternCallStackIndex(codeAddress, start); } @@ -7869,7 +7974,7 @@ private unsafe CallStackIndex GetStackIndexForStackEvent64(ulong* addresses, int { for (var it = &addresses[addressCount]; it-- != addresses;) { - CodeAddressIndex codeAddress = codeAddresses.GetOrCreateCodeAddressIndex(process, *it); + CodeAddressIndex codeAddress = codeAddresses.GetOrCreateCodeAddressIndex(process, BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes((ulong)(*it)))); start = InternCallStackIndex(codeAddress, start); } @@ -7940,11 +8045,11 @@ void IFastSerializable.ToStream(Serializer serializer) lazyCallStacks.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(callStacks.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(callStacks.Count))); for (int i = 0; i < callStacks.Count; i++) { - serializer.Write((int)callStacks[i].codeAddressIndex); - serializer.Write((int)callStacks[i].callerIndex); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)callStacks[i].codeAddressIndex))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)callStacks[i].callerIndex))); } serializer.Log("\r\n"); }); @@ -9331,22 +9436,22 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(methods); serializer.WriteTagged(CodeAddressInfoSerializationVersion); - serializer.Write(codeAddresses.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(codeAddresses.Count))); serializer.Log("\r\n"); for (int i = 0; i < codeAddresses.Count; i++) { - serializer.WriteAddress(codeAddresses[i].Address); - serializer.Write((int)codeAddresses[i].moduleFileIndex); - serializer.Write((int)codeAddresses[i].methodOrProcessOrIlMapIndex); - serializer.Write(codeAddresses[i].InclusiveCount); + serializer.WriteAddress(BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes((ulong)codeAddresses[i].Address))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)codeAddresses[i].moduleFileIndex))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)codeAddresses[i].methodOrProcessOrIlMapIndex))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(codeAddresses[i].InclusiveCount))); // 'CodeAddressInfoSerializationVersion' >= 1 serializer.Write((byte)codeAddresses[i].optimizationTier); } - serializer.Write(totalCodeAddresses); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(totalCodeAddresses))); serializer.Log("\r\n"); - serializer.Write(ILToNativeMaps.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(ILToNativeMaps.Count))); for (int i = 0; i < ILToNativeMaps.Count; i++) { serializer.Write(ILToNativeMaps[i]); @@ -9719,8 +9824,8 @@ internal void Deserialize(Deserializer deserializer) } internal void Serialize(Serializer serializer) { - serializer.Write(ILOffset); - serializer.Write(NativeOffset); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(ILOffset))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(NativeOffset))); } } @@ -9782,11 +9887,11 @@ public int GetILOffsetForNativeAddress(Address nativeAddress) void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write((int)MethodIndex); - serializer.Write((long)MethodStart); - serializer.Write(MethodLength); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)MethodIndex))); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)MethodStart))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(MethodLength))); - serializer.Write(Map.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(Map.Count))); for (int i = 0; i < Map.Count; i++) { Map[i].Serialize(serializer); @@ -10175,13 +10280,13 @@ void IFastSerializable.ToStream(Serializer serializer) lazyMethods.Write(serializer, delegate { serializer.Write(codeAddresses); - serializer.Write(methods.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(methods.Count))); serializer.Log("\r\n"); for (int i = 0; i < methods.Count; i++) { serializer.Write(methods[i].fullMethodName); - serializer.Write(methods[i].methodDefOrRva); - serializer.Write((int)methods[i].moduleIndex); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(methods[i].methodDefOrRva))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)methods[i].moduleIndex))); } serializer.Log("\r\n"); }); @@ -10493,7 +10598,7 @@ internal TraceModuleFiles(TraceLog log) void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(log); - serializer.Write(moduleFiles.Count); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(moduleFiles.Count))); for (int i = 0; i < moduleFiles.Count; i++) { serializer.Write(moduleFiles[i]); @@ -10802,7 +10907,7 @@ internal TraceModuleFile(string fileName, Address imageBase, ModuleFileIndex mod void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(fileName); - serializer.Write(imageSize); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(imageSize))); serializer.WriteAddress(imageBase); // Write symbol info with format discriminator @@ -10815,10 +10920,10 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(fileVersion); serializer.Write(productVersion); - serializer.Write(timeDateStamp); - serializer.Write(imageChecksum); - serializer.Write((int)moduleFileIndex); - serializer.Write(codeAddressesInModule); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(timeDateStamp))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(imageChecksum))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)moduleFileIndex))); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(codeAddressesInModule))); serializer.Write(managedModule); } void IFastSerializable.FromStream(Deserializer deserializer) @@ -10912,12 +11017,12 @@ internal override void ToStream(Serializer serializer) { serializer.Write(PdbName); serializer.Write(PdbSignature); - serializer.Write(PdbAge); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(PdbAge))); serializer.Write(IsReadyToRun); serializer.Write(R2RPerfMapSignature); - serializer.Write(R2RPerfMapVersion); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(R2RPerfMapVersion))); serializer.Write(R2RPerfMapName); - serializer.Write((int)R2RImageTextVirtualOffset); + serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)R2RImageTextVirtualOffset))); } internal override void FromStream(Deserializer deserializer) @@ -11698,7 +11803,7 @@ internal static class SerializerExtentions { public static void WriteAddress(this Serializer serializer, Address address) { - serializer.Write((long)address); + serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)address))); } public static void ReadAddress(this Deserializer deserializer, out Address address) { From a4a26358c39fc73e034738cfc41e5ddce359be3a Mon Sep 17 00:00:00 2001 From: sanjam panda Date: Thu, 11 Jun 2026 13:18:17 +0000 Subject: [PATCH 2/2] refactor patch --- src/FastSerialization/FastSerialization.cs | 29 ++- src/FastSerialization/StreamReaderWriter.cs | 26 ++- src/TraceEvent/DynamicTraceEventParser.cs | 14 +- src/TraceEvent/Parsers/ClrTraceEventParser.cs | 2 +- src/TraceEvent/RegisteredTraceEventParser.cs | 4 +- src/TraceEvent/TraceEvent.cs | 2 +- src/TraceEvent/TraceLog.cs | 192 +++++++++--------- 7 files changed, 150 insertions(+), 119 deletions(-) diff --git a/src/FastSerialization/FastSerialization.cs b/src/FastSerialization/FastSerialization.cs index cf3a1cdb7..c508d58e5 100644 --- a/src/FastSerialization/FastSerialization.cs +++ b/src/FastSerialization/FastSerialization.cs @@ -9,8 +9,8 @@ using System.Diagnostics; using System.IO; using System.Text; // For StringBuilder. -using System.Buffers.Binary; using System.Runtime.InteropServices; +using System.Buffers.Binary; // see #Introduction and #SerializerIntroduction namespace FastSerialization { @@ -185,6 +185,10 @@ interface IStreamWriter : IDisposable /// void Write(int value); /// + /// Write an blob to a stream + /// + void WriteBlobAsInt(int value); + /// /// Write a long to a stream /// void Write(long value); @@ -605,7 +609,7 @@ public Serializer(IStreamWriter writer, IFastSerializable entryObject) Log(""); if (forwardReferenceDefinitions != null) { - Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(forwardReferenceDefinitions.Count))); + Write(forwardReferenceDefinitions.Count); for (int i = 0; i < forwardReferenceDefinitions.Count; i++) { Debug.Assert(forwardReferenceDefinitions[i] != StreamLabel.Invalid); @@ -675,6 +679,14 @@ public void Write(int value) writer.Write(value); } /// + /// Write an blob to a stream + /// + public void WriteBlobAsInt(int value) + { + Log(""); + writer.WriteBlobAsInt(value); + } + /// /// Write a long to a stream /// public void Write(long value) @@ -823,15 +835,15 @@ public void DefineForwardReference(ForwardReference forwardReference) /// /// Write a byte preceded by a tag that indicates its a short. These should be read with the corresponding TryReadTagged operation /// - public void WriteTagged(short value) { WriteTag(Tags.Int16); Write(BinaryPrimitives.ReadInt16LittleEndian(BitConverter.GetBytes(value))); } + public void WriteTagged(short value) { WriteTag(Tags.Int16); Write(value); } /// /// Write a byte preceded by a tag that indicates its a int. These should be read with the corresponding TryReadTagged operation /// - public void WriteTagged(int value) { WriteTag(Tags.Int32); Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(value))); } + public void WriteTagged(int value) { WriteTag(Tags.Int32); Write(value); } /// /// Write a byte preceded by a tag that indicates its a long. These should be read with the corresponding TryReadTagged operation /// - public void WriteTagged(long value) { WriteTag(Tags.Int64); Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(value))); } + public void WriteTagged(long value) { WriteTag(Tags.Int64); Write(value); } /// /// Write a byte preceded by a tag that indicates its a string. These should be read with the corresponding TryReadTagged operation /// @@ -1599,6 +1611,7 @@ public StreamLabel ResolveForwardReference(ForwardReference reference, bool pres reader.GotoSuffixLabel(); Log(""); StreamLabel forwardRefsLabel = reader.ReadLabel(); + Goto(forwardRefsLabel); int fowardRefCount = reader.ReadInt32(); Log("\r\n"); // We actually don't use the this pointer! We did this for symmetry with Read ForwardReference endRegion = serializer.GetForwardReference(); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)endRegion))); // Allow the reader to skip this. + serializer.Write(endRegion); // Allow the reader to skip this. toStream(); // Write the deferred data. serializer.DefineForwardReference(endRegion); serializer.Log("\r\n"); @@ -2510,8 +2523,8 @@ internal SerializationType(string fullName, Deserializer deserializer) } void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(version))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(minimumReaderVersion))); + serializer.Write(version); + serializer.Write(minimumReaderVersion); serializer.Write(fullName); } void IFastSerializable.FromStream(Deserializer deserializer) diff --git a/src/FastSerialization/StreamReaderWriter.cs b/src/FastSerialization/StreamReaderWriter.cs index 376ac0de9..68eed0099 100644 --- a/src/FastSerialization/StreamReaderWriter.cs +++ b/src/FastSerialization/StreamReaderWriter.cs @@ -260,7 +260,7 @@ public MemoryStreamWriter(SerializationSettings settings, int initialSize = 64) writeLabel = (value) => { Debug.Assert((long)value <= int.MaxValue); - Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)value))); + Write((int)value); }; } else @@ -268,7 +268,7 @@ public MemoryStreamWriter(SerializationSettings settings, int initialSize = 64) writeLabel = (value) => { Debug.Assert((long)value <= long.MaxValue); - Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)value))); + Write((long)value); }; } @@ -329,6 +329,7 @@ public void Write(byte value) /// public unsafe void Write(short value) { + value = BinaryPrimitives.ReadInt16LittleEndian(BitConverter.GetBytes(value)); if (endPosition + sizeof(short) > bytes.Length) { MakeSpace(); @@ -345,6 +346,24 @@ public unsafe void Write(short value) /// Implementation of IStreamWriter /// public unsafe void Write(int value) + { + value = BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(value)); + if (endPosition + sizeof(int) > bytes.Length) + { + MakeSpace(); + } + + fixed (byte* data = bytes) + { + *(int*)(data + endPosition) = value; + } + + endPosition += sizeof(int); + } + /// + /// Write an blob to a stream + /// + public unsafe void WriteBlobAsInt(int value) { if (endPosition + sizeof(int) > bytes.Length) { @@ -363,6 +382,7 @@ public unsafe void Write(int value) /// public unsafe void Write(long value) { + value = BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(value)); if (endPosition + sizeof(long) > bytes.Length) { MakeSpace(); @@ -393,7 +413,7 @@ public void Write(string value) } else { - Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(value.Length))); + Write(value.Length); for (int i = 0; i < value.Length; i++) { char c = value[i]; diff --git a/src/TraceEvent/DynamicTraceEventParser.cs b/src/TraceEvent/DynamicTraceEventParser.cs index 044c983e5..7415c4637 100644 --- a/src/TraceEvent/DynamicTraceEventParser.cs +++ b/src/TraceEvent/DynamicTraceEventParser.cs @@ -12,7 +12,7 @@ using System.Text.RegularExpressions; using System.Xml; using Address = System.UInt64; -using System.Buffers.Binary; + namespace Microsoft.Diagnostics.Tracing.Parsers { /// @@ -1830,11 +1830,11 @@ public override string ToString() public void ToStream(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventID))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)task))); + serializer.Write((int)eventID); + serializer.Write((int)task); serializer.Write(taskName); serializer.Write(taskGuid); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)opcode))); + serializer.Write((int)opcode); serializer.Write(opcodeName); serializer.Write(providerGuid); serializer.Write(providerName); @@ -1843,13 +1843,13 @@ public void ToStream(Serializer serializer) serializer.Write(lookupAsWPP); serializer.Write(containsSelfDescribingMetadata); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(payloadNames.Length))); + serializer.Write(payloadNames.Length); foreach (var payloadName in payloadNames) { serializer.Write(payloadName); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(payloadFetches.Length))); + serializer.Write(payloadFetches.Length); foreach (var payloadFetch in payloadFetches) { payloadFetch.ToStream(serializer); @@ -1983,7 +1983,7 @@ internal class DynamicTraceEventParserState : IFastSerializable void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(providers.Count))); + serializer.Write(providers.Count); foreach (ProviderManifest provider in providers.Values) { serializer.Write(provider); diff --git a/src/TraceEvent/Parsers/ClrTraceEventParser.cs b/src/TraceEvent/Parsers/ClrTraceEventParser.cs index e8534306c..9d034931d 100644 --- a/src/TraceEvent/Parsers/ClrTraceEventParser.cs +++ b/src/TraceEvent/Parsers/ClrTraceEventParser.cs @@ -6,6 +6,7 @@ using System.Diagnostics; using System.Runtime.InteropServices; using System.Text; +using System.Buffers.Binary; using Address = System.UInt64; // This file was generated with the following command: @@ -4811,7 +4812,6 @@ public sealed class GCBulkNodeTraceData : TraceEvent ret->EdgeCount = BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(ret->EdgeCount)); } } - Debug.Assert((ret->Address & 0xFF00000000000003L) == 0); Debug.Assert((ret->TypeID & 0xFF00000000000001L) == 0); Debug.Assert(ret->Size < 0x80000000L); diff --git a/src/TraceEvent/RegisteredTraceEventParser.cs b/src/TraceEvent/RegisteredTraceEventParser.cs index ad815bd7a..a971d4c4f 100644 --- a/src/TraceEvent/RegisteredTraceEventParser.cs +++ b/src/TraceEvent/RegisteredTraceEventParser.cs @@ -11,7 +11,7 @@ using System.Text; using System.Text.RegularExpressions; using System.Xml; -using System.Buffers.Binary; + namespace Microsoft.Diagnostics.Tracing.Parsers { /// @@ -1567,7 +1567,7 @@ public virtual void ToStream(Serializer serializer) } } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(count))); + serializer.Write(count); foreach (var template in m_templates.Values) { if (template != null) diff --git a/src/TraceEvent/TraceEvent.cs b/src/TraceEvent/TraceEvent.cs index 08c08079a..43b71571b 100644 --- a/src/TraceEvent/TraceEvent.cs +++ b/src/TraceEvent/TraceEvent.cs @@ -4667,7 +4667,7 @@ internal static unsafe string ReadUnicodeString(IntPtr pointer, int offset, int curPos++; } - return new string(temp, 0 curPos); + return new string(temp, 0, curPos); } char* charEnd = (char*)(ptr + bufferLength); diff --git a/src/TraceEvent/TraceLog.cs b/src/TraceEvent/TraceLog.cs index 28aada15d..b0ca7f164 100644 --- a/src/TraceEvent/TraceLog.cs +++ b/src/TraceEvent/TraceLog.cs @@ -35,7 +35,6 @@ using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; - using Address = System.UInt64; namespace Microsoft.Diagnostics.Tracing.Etlx @@ -3279,7 +3278,6 @@ internal unsafe bool ProcessExtendedData(TraceEvent data, ushort extendedDataCou if (extendedData[i].ExtType == TraceEventNativeMethods.EVENT_HEADER_EXT_TYPE_STACK_TRACE64 || extendedData[i].ExtType == TraceEventNativeMethods.EVENT_HEADER_EXT_TYPE_STACK_TRACE32) { - int pointerSize = (extendedData[i].ExtType == TraceEventNativeMethods.EVENT_HEADER_EXT_TYPE_STACK_TRACE64) ? 8 : 4; var stackRecord = (TraceEventNativeMethods.EVENT_EXTENDED_ITEM_STACK_TRACE64*)extendedData[i].DataPtr; // TODO Debug.Assert(stackRecord->MatchId == 0); @@ -3474,7 +3472,7 @@ private static unsafe void WriteBlob(IntPtr source, IStreamWriter writer, int by int intCount = byteCount >> 2; while (intCount > 0) { - writer.Write(*sourcePtr++); + writer.WriteBlobAsInt(*sourcePtr++); --intCount; } } @@ -3920,7 +3918,7 @@ void IFastSerializable.ToStream(Serializer serializer) { if (i == 2) { - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(long.MaxValue))); + serializer.Write(long.MaxValue); } else { @@ -3935,20 +3933,20 @@ void IFastSerializable.ToStream(Serializer serializer) }); serializer.Log(""); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(_syncTimeUTC.ToFileTimeUtc()))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(pointerSize))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(numberOfProcessors))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cpuSpeedMHz))); + serializer.Write(_syncTimeUTC.ToFileTimeUtc()); + serializer.Write(pointerSize); + serializer.Write(numberOfProcessors); + serializer.Write(cpuSpeedMHz); serializer.Write((byte)osVersion.Major); serializer.Write((byte)osVersion.Minor); serializer.Write((byte)osVersion.MajorRevision); serializer.Write((byte)osVersion.MinorRevision); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(QPCFreq))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(sessionStartTimeQPC))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(sessionEndTimeQPC))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsLost))); + serializer.Write(QPCFreq); + serializer.Write(sessionStartTimeQPC); + serializer.Write(sessionEndTimeQPC); + serializer.Write(eventsLost); serializer.Write(machineName); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(memorySizeMeg))); + serializer.Write(memorySizeMeg); serializer.Write(processes); serializer.Write(threads); @@ -3958,29 +3956,29 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(moduleFiles); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventPages.Count))); + serializer.Write(eventPages.Count); for (int i = 0; i < eventPages.Count; i++) { - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(eventPages[i].TimeQPC))); + serializer.Write(eventPages[i].TimeQPC); serializer.Write(eventPages[i].Position); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventPages.Count))); // redundant as a checksum + serializer.Write(eventPages.Count); // redundant as a checksum serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventCount))); + serializer.Write(eventCount); serializer.Log(""); lazyEventsToStacks.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToStacks.Count))); + serializer.Write(eventsToStacks.Count); for (int i = 0; i < eventsToStacks.Count; i++) { EventsToStackIndex eventToStack = eventsToStacks[i]; Debug.Assert(i == 0 || eventsToStacks[i - 1].EventIndex <= eventsToStacks[i].EventIndex, "event list not sorted"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.EventIndex))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.CallStackIndex))); + serializer.Write((int)eventToStack.EventIndex); + serializer.Write((int)eventToStack.CallStackIndex); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToStacks.Count))); // Redundant as a checksum + serializer.Write(eventsToStacks.Count); // Redundant as a checksum serializer.Log("\r\n"); }); @@ -3988,15 +3986,15 @@ void IFastSerializable.ToStream(Serializer serializer) lazyEventsToStacks.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cswitchBlockingEventsToStacks.Count))); + serializer.Write(cswitchBlockingEventsToStacks.Count); for (int i = 0; i < cswitchBlockingEventsToStacks.Count; i++) { EventsToStackIndex eventToStack = cswitchBlockingEventsToStacks[i]; Debug.Assert(i == 0 || cswitchBlockingEventsToStacks[i - 1].EventIndex <= cswitchBlockingEventsToStacks[i].EventIndex, "event list not sorted"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.EventIndex))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventToStack.CallStackIndex))); + serializer.Write((int)eventToStack.EventIndex); + serializer.Write((int)eventToStack.CallStackIndex); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cswitchBlockingEventsToStacks.Count))); // Redundant as a checksum + serializer.Write(cswitchBlockingEventsToStacks.Count); // Redundant as a checksum serializer.Log("\r\n"); }); @@ -4004,44 +4002,44 @@ void IFastSerializable.ToStream(Serializer serializer) lazyEventsToCodeAddresses.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToCodeAddresses.Count))); + serializer.Write(eventsToCodeAddresses.Count); foreach (EventsToCodeAddressIndex eventsToCodeAddress in eventsToCodeAddresses) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventsToCodeAddress.EventIndex))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)eventsToCodeAddress.Address))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)eventsToCodeAddress.CodeAddressIndex))); + serializer.Write((int)eventsToCodeAddress.EventIndex); + serializer.Write((long)eventsToCodeAddress.Address); + serializer.Write((int)eventsToCodeAddress.CodeAddressIndex); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(eventsToCodeAddresses.Count))); // Redundant as a checksum + serializer.Write(eventsToCodeAddresses.Count); // Redundant as a checksum serializer.Log("\r\n"); }); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(userData.Count))); + serializer.Write(userData.Count); foreach (KeyValuePair pair in UserData) { serializer.Write(pair.Key); IFastSerializable asFastSerializable = (IFastSerializable)pair.Value; serializer.Write(asFastSerializable); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(userData.Count))); // Redundant as a checksum + serializer.Write(userData.Count); // Redundant as a checksum serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(sampleProfileInterval100ns))); + serializer.Write(sampleProfileInterval100ns); serializer.Write(osName); serializer.Write(osBuild); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(bootTime100ns))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(utcOffsetMinutes ?? int.MinValue))); + serializer.Write(bootTime100ns); + serializer.Write(utcOffsetMinutes ?? int.MinValue); serializer.Write(hasPdbInfo); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(relatedActivityIDs.Count))); + serializer.Write(relatedActivityIDs.Count); for (int i = 0; i < relatedActivityIDs.Count; i++) { serializer.Write(relatedActivityIDs[i]); } serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(containerIDs.Count))); + serializer.Write(containerIDs.Count); for (int i = 0; i < containerIDs.Count; i++) { serializer.Write(containerIDs[i]); @@ -4050,7 +4048,7 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Log("\r\n"); serializer.Write(truncated); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)firstTimeInversion))); + serializer.Write((int)firstTimeInversion); } void IFastSerializable.FromStream(Deserializer deserializer) { @@ -4872,7 +4870,7 @@ internal TraceEventCounts GetEventCounts(TraceEvent data) void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(m_log); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(m_counts.Count))); + serializer.Write(m_counts.Count); foreach (var counts in m_counts.Values) { serializer.Write(counts); @@ -4958,7 +4956,7 @@ public override int GetHashCode() public void Serialize(Serializer serializer) { serializer.Write(m_providerGuid); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)m_eventId))); + serializer.Write((int)m_eventId); serializer.Write(m_classicProvider); } } @@ -5202,9 +5200,9 @@ void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(m_stats); m_key.Serialize(serializer); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(m_count))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(m_stackCount))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(m_eventDataLenTotal))); + serializer.Write(m_count); + serializer.Write(m_stackCount); + serializer.Write(m_eventDataLenTotal); } void IFastSerializable.FromStream(Deserializer deserializer) { @@ -5815,7 +5813,7 @@ void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(log); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(processes.Count))); + serializer.Write(processes.Count); for (int i = 0; i < processes.Count; i++) { serializer.Write(processes[i]); @@ -5824,7 +5822,7 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Log("\r\n"); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(processesByPID.Count))); + serializer.Write(processesByPID.Count); for (int i = 0; i < processesByPID.Count; i++) { serializer.Write(processesByPID[i]); @@ -6221,24 +6219,24 @@ internal TraceProcess(int processID, TraceLog log, ProcessIndex processIndex) void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(processID))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)processIndex))); + serializer.Write(processID); + serializer.Write((int)processIndex); serializer.Write(log); serializer.Write(commandLine); serializer.Write(imageFileName); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(firstEventSeenQPC))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(startTimeQPC))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(endTimeQPC))); + serializer.Write(firstEventSeenQPC); + serializer.Write(startTimeQPC); + serializer.Write(endTimeQPC); serializer.Write(exitStatus.HasValue); if (exitStatus.HasValue) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(exitStatus.Value))); + serializer.Write(exitStatus.Value); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(parentID))); + serializer.Write(parentID); serializer.Write(parent); serializer.Write(loadedModules); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cpuSamples))); + serializer.Write(cpuSamples); serializer.Write(loadedAModuleHigh); serializer.Write(anyModuleLoaded); } @@ -6683,7 +6681,7 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(log); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(threads.Count))); + serializer.Write(threads.Count); for (int i = 0; i < threads.Count; i++) { serializer.Write(threads[i]); @@ -6877,20 +6875,20 @@ internal TraceThread(int threadID, TraceProcess process, ThreadIndex threadIndex void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(threadID))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)threadIndex))); + serializer.Write(threadID); + serializer.Write((int)threadIndex); serializer.Write(process); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(startTimeQPC))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(endTimeQPC))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(cpuSamples))); + serializer.Write(startTimeQPC); + serializer.Write(endTimeQPC); + serializer.Write(cpuSamples); serializer.Write(threadInfo); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)userStackBase))); + serializer.Write((long)userStackBase); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(activityIds.Count))); + serializer.Write(activityIds.Count); serializer.Log("\r\n"); foreach (ActivityIndex entry in activityIds) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)entry))); + serializer.Write((int)entry); } serializer.Log("\r\n"); @@ -7491,7 +7489,7 @@ void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(process); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(modules.Count))); + serializer.Write(modules.Count); for (int i = 0; i < modules.Count; i++) { serializer.Write(modules[i]); @@ -7663,12 +7661,12 @@ internal TraceLoadedModule(TraceProcess process, TraceModuleFile moduleFile, lon void IFastSerializable.ToStream(Serializer serializer) { ToStream(serializer); } internal void ToStream(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(loadTimeQPC))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(unloadTimeQPC))); + serializer.Write(loadTimeQPC); + serializer.Write(unloadTimeQPC); serializer.Write(managedModule); serializer.Write(process); serializer.Write(moduleFile); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)key))); + serializer.Write((long)key); serializer.Write(overlaps); } /// @@ -7763,9 +7761,9 @@ internal void InitializeNativeModuleIsReadyToRun() void IFastSerializable.ToStream(Serializer serializer) { base.ToStream(serializer); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(assemblyID))); + serializer.Write(assemblyID); serializer.Write(nativeModule); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)flags))); + serializer.Write((int)flags); } void IFastSerializable.FromStream(Deserializer deserializer) { @@ -8045,11 +8043,11 @@ void IFastSerializable.ToStream(Serializer serializer) lazyCallStacks.Write(serializer, delegate { serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(callStacks.Count))); + serializer.Write(callStacks.Count); for (int i = 0; i < callStacks.Count; i++) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)callStacks[i].codeAddressIndex))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)callStacks[i].callerIndex))); + serializer.Write((int)callStacks[i].codeAddressIndex); + serializer.Write((int)callStacks[i].callerIndex); } serializer.Log("\r\n"); }); @@ -9436,22 +9434,22 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(methods); serializer.WriteTagged(CodeAddressInfoSerializationVersion); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(codeAddresses.Count))); + serializer.Write(codeAddresses.Count); serializer.Log("\r\n"); for (int i = 0; i < codeAddresses.Count; i++) { - serializer.WriteAddress(BinaryPrimitives.ReadUInt64LittleEndian(BitConverter.GetBytes((ulong)codeAddresses[i].Address))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)codeAddresses[i].moduleFileIndex))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)codeAddresses[i].methodOrProcessOrIlMapIndex))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(codeAddresses[i].InclusiveCount))); + serializer.WriteAddress(codeAddresses[i].Address); + serializer.Write((int)codeAddresses[i].moduleFileIndex); + serializer.Write((int)codeAddresses[i].methodOrProcessOrIlMapIndex); + serializer.Write(codeAddresses[i].InclusiveCount); // 'CodeAddressInfoSerializationVersion' >= 1 serializer.Write((byte)codeAddresses[i].optimizationTier); } - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(totalCodeAddresses))); + serializer.Write(totalCodeAddresses); serializer.Log("\r\n"); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(ILToNativeMaps.Count))); + serializer.Write(ILToNativeMaps.Count); for (int i = 0; i < ILToNativeMaps.Count; i++) { serializer.Write(ILToNativeMaps[i]); @@ -9824,8 +9822,8 @@ internal void Deserialize(Deserializer deserializer) } internal void Serialize(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(ILOffset))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(NativeOffset))); + serializer.Write(ILOffset); + serializer.Write(NativeOffset); } } @@ -9887,11 +9885,11 @@ public int GetILOffsetForNativeAddress(Address nativeAddress) void IFastSerializable.ToStream(Serializer serializer) { - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)MethodIndex))); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)MethodStart))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(MethodLength))); + serializer.Write((int)MethodIndex); + serializer.Write((long)MethodStart); + serializer.Write(MethodLength); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(Map.Count))); + serializer.Write(Map.Count); for (int i = 0; i < Map.Count; i++) { Map[i].Serialize(serializer); @@ -10280,13 +10278,13 @@ void IFastSerializable.ToStream(Serializer serializer) lazyMethods.Write(serializer, delegate { serializer.Write(codeAddresses); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(methods.Count))); + serializer.Write(methods.Count); serializer.Log("\r\n"); for (int i = 0; i < methods.Count; i++) { serializer.Write(methods[i].fullMethodName); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(methods[i].methodDefOrRva))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)methods[i].moduleIndex))); + serializer.Write(methods[i].methodDefOrRva); + serializer.Write((int)methods[i].moduleIndex); } serializer.Log("\r\n"); }); @@ -10598,7 +10596,7 @@ internal TraceModuleFiles(TraceLog log) void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(log); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(moduleFiles.Count))); + serializer.Write(moduleFiles.Count); for (int i = 0; i < moduleFiles.Count; i++) { serializer.Write(moduleFiles[i]); @@ -10907,7 +10905,7 @@ internal TraceModuleFile(string fileName, Address imageBase, ModuleFileIndex mod void IFastSerializable.ToStream(Serializer serializer) { serializer.Write(fileName); - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes(imageSize))); + serializer.Write(imageSize); serializer.WriteAddress(imageBase); // Write symbol info with format discriminator @@ -10920,10 +10918,10 @@ void IFastSerializable.ToStream(Serializer serializer) serializer.Write(fileVersion); serializer.Write(productVersion); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(timeDateStamp))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(imageChecksum))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)moduleFileIndex))); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(codeAddressesInModule))); + serializer.Write(timeDateStamp); + serializer.Write(imageChecksum); + serializer.Write((int)moduleFileIndex); + serializer.Write(codeAddressesInModule); serializer.Write(managedModule); } void IFastSerializable.FromStream(Deserializer deserializer) @@ -11017,12 +11015,12 @@ internal override void ToStream(Serializer serializer) { serializer.Write(PdbName); serializer.Write(PdbSignature); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(PdbAge))); + serializer.Write(PdbAge); serializer.Write(IsReadyToRun); serializer.Write(R2RPerfMapSignature); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes(R2RPerfMapVersion))); + serializer.Write(R2RPerfMapVersion); serializer.Write(R2RPerfMapName); - serializer.Write(BinaryPrimitives.ReadInt32LittleEndian(BitConverter.GetBytes((int)R2RImageTextVirtualOffset))); + serializer.Write((int)R2RImageTextVirtualOffset); } internal override void FromStream(Deserializer deserializer) @@ -11803,7 +11801,7 @@ internal static class SerializerExtentions { public static void WriteAddress(this Serializer serializer, Address address) { - serializer.Write(BinaryPrimitives.ReadInt64LittleEndian(BitConverter.GetBytes((long)address))); + serializer.Write((long)address); } public static void ReadAddress(this Deserializer deserializer, out Address address) {