static protected uint ReadAndUnpackBits(_DBG.BitStream stream) { const int SHIFT_PER_NIBBLE = 2; //2^2 = 4 bits per nibble uint nibbles = stream.ReadBits(Packets.Commands.Bits.NibbleCount) + 1; return(stream.ReadBits((int)nibbles << SHIFT_PER_NIBBLE)); }
public TimestampPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Timestamp) { ulong l = (ulong)ReadAndUnpackBits(stream) << Packets.Commands.Bits.TimestampShift; m_time = l / TimeSpan.TicksPerMillisecond; Tracing.PacketTrace("time {0}", m_time); }
static protected uint ReadMethodDefIndex(_DBG.BitStream stream) { uint assembly = ReadAndUnpackBits(stream); uint method = ReadAndUnpackBits(stream); return(assembly << ASSEMBLY_BIT_OFFSET | method); }
static protected uint ReadTypeDefIndex(_DBG.BitStream stream) { uint assembly = ReadAndUnpackBits(stream); uint type = ReadAndUnpackBits(stream); return(assembly << ASSEMBLY_BIT_OFFSET | type); }
public HeapDumpObjectPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_HeapDump_Object) { m_address = ReadAndUnpackBits(stream); m_size = ReadAndUnpackBits(stream) * ProfilerSession.HeapBlockSize; m_dt = (_DBG.RuntimeDataType)stream.ReadBits(Commands.Bits.DataType); if (m_dt == _DBG.RuntimeDataType.DATATYPE_CLASS || m_dt == _DBG.RuntimeDataType.DATATYPE_VALUETYPE) { m_typedef = ReadTypeDefIndex(stream); } else if (m_dt == _DBG.RuntimeDataType.DATATYPE_SZARRAY) { m_arrayElementType = ReadTypeDefIndex(stream); m_arrayLevels = (ushort)ReadAndUnpackBits(stream); } m_refs = new List <uint>(); bool moreRefs; while (moreRefs = ReadBoolean(stream)) { m_refs.Add(ReadAndUnpackBits(stream)); } }
internal static Packets.ProfilerPacket Decode(_DBG.BitStream stream) { uint type = stream.ReadBits(Packets.Commands.Bits.CommandHeader); Tracing.PacketTrace("New Packet {0}", type); switch (type) { case Packets.Commands.c_Profiling_Timestamp: return(new Packets.TimestampPacket(stream)); case Packets.Commands.c_Profiling_Memory_Layout: return(new Packets.MemoryLayoutPacket(stream)); case Packets.Commands.c_Profiling_HeapDump_Start: return(new Packets.HeapDumpStartPacket(stream)); case Packets.Commands.c_Profiling_HeapDump_Stop: return(new Packets.HeapDumpStopPacket(stream)); case Packets.Commands.c_Profiling_HeapDump_Root: return(new Packets.HeapDumpRootPacket(stream)); case Packets.Commands.c_Profiling_HeapDump_Object: return(new Packets.HeapDumpObjectPacket(stream)); case Packets.Commands.c_Profiling_Calls_Call: return(new Packets.CallPacket(stream)); case Packets.Commands.c_Profiling_Calls_Return: return(new Packets.ReturnPacket(stream)); case Packets.Commands.c_Profiling_Calls_CtxSwitch: return(new Packets.ContextSwitchPacket(stream)); case Packets.Commands.c_Profiling_Allocs_Alloc: return(new Packets.ObjectAllocationPacket(stream)); case Packets.Commands.c_Profiling_Allocs_Relloc: return(new Packets.ObjectRelocationPacket(stream)); case Packets.Commands.c_Profiling_Allocs_Delete: return(new Packets.ObjectDeletionPacket(stream)); case Packets.Commands.c_Profiling_GarbageCollect_Begin: return(new Packets.GarbageCollectionBeginPacket(stream)); case Packets.Commands.c_Profiling_GarbageCollect_End: return(new Packets.GarbageCollectionEndPacket(stream)); case Packets.Commands.c_Profiling_HeapCompact_Begin: return(new Packets.HeapCompactionBeginPacket(stream)); case Packets.Commands.c_Profiling_HeapCompact_End: return(new Packets.HeapCompactionEndPacket(stream)); default: throw new ApplicationException("Unable to decode packet."); } }
public CallPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Calls_Call) { if (ReadBoolean(stream)) { m_assembly = ReadAndUnpackBits(stream); Debug.Assert(m_assembly != 0); } m_method = ReadAndUnpackBits(stream); }
public HeapDumpRootPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_HeapDump_Root) { m_address = ReadAndUnpackBits(stream); m_source = stream.ReadBits(Packets.Commands.Bits.RootTypes); switch (m_source) { case Packets.Commands.RootTypes.Root_Stack: m_method = ReadMethodDefIndex(stream); break; } Tracing.PacketTrace("root type:{0} at {1}", m_source, m_address); }
public ObjectRelocationPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Allocs_Relloc) { uint count = ReadAndUnpackBits(stream); reloc = new ObjectRelocation.RelocationRegion[count]; for (uint i = 0; i < count; i++) { reloc[i] = new ObjectRelocation.RelocationRegion(); reloc[i].m_start = ReadAndUnpackBits(stream); reloc[i].m_end = ReadAndUnpackBits(stream); reloc[i].m_offset = ReadAndUnpackBits(stream); } }
public ObjectAllocationPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Allocs_Alloc) { m_address = ReadAndUnpackBits(stream); m_size = ReadAndUnpackBits(stream) * ProfilerSession.HeapBlockSize; m_dt = (_DBG.RuntimeDataType)stream.ReadBits(Commands.Bits.DataType); if (m_dt == _DBG.RuntimeDataType.DATATYPE_CLASS || m_dt == _DBG.RuntimeDataType.DATATYPE_VALUETYPE || m_dt == _DBG.RuntimeDataType.DATATYPE_SZARRAY) { m_type = ReadTypeDefIndex(stream); if (m_dt == _DBG.RuntimeDataType.DATATYPE_SZARRAY) { m_rank = (ushort)ReadAndUnpackBits(stream); } } else { m_type = (uint)m_dt; } }
public ProfilerSession(_DBG.Engine engine) { if (engine == null) { throw new ArgumentNullException(); } m_connected = true; m_engine = engine; m_engine.OnCommand += new _DBG.CommandEventHandler(OnDeviceCommand); m_incomingStream = new _DBG.BitStream(true); m_startTime = 0; m_lastKnownTime = 0; m_currentHeapDump = null; m_threadCallStacks = new Dictionary<uint, Stack<uint>>(); m_liveObjectTable = new List<uint>(); m_firstPacket = true; m_receiverThread = new Thread(WorkerThread); m_receiverThread.Start(); }
public ProfilerSession(_DBG.Engine engine) { if (engine == null) { throw new ArgumentNullException(); } m_connected = true; m_engine = engine; m_engine.OnCommand += new _DBG.CommandEventHandler(OnDeviceCommand); m_incomingStream = new _DBG.BitStream(true); m_startTime = 0; m_lastKnownTime = 0; m_currentHeapDump = null; m_threadCallStacks = new Dictionary <uint, Stack <uint> >(); m_liveObjectTable = new List <uint>(); m_firstPacket = true; m_receiverThread = new Thread(WorkerThread); m_receiverThread.Start(); }
private void InitializeForDeserialization(Type t, byte[] data, int pos, int len) { m_stream = new BitStream(data, pos, len); m_value = null; Initialize(t, true); }
private void InitializeForSerialization(Type t, object o) { m_stream = new BitStream(); m_value = o; Initialize(t, false); }
public GarbageCollectionEndPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_GarbageCollect_End) { m_freeBytes = ReadAndUnpackBits(stream); }
public HeapCompactionEndPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_HeapCompact_End) { m_freeBytes = ReadAndUnpackBits(stream); }
static protected bool ReadBoolean(_DBG.BitStream stream) { return(stream.ReadBits(1) == 1); }
public ObjectDeletionPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Allocs_Delete) { m_address = ReadAndUnpackBits(stream); }
public MemoryLayoutPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Memory_Layout) { m_heapAddress = ReadAndUnpackBits(stream); m_heapLength = ReadAndUnpackBits(stream); Tracing.PacketTrace("layout {0}:{1}", m_heapAddress, m_heapLength); }
public ContextSwitchPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Calls_Call) { m_thread = ReadAndUnpackBits(stream); }
public ReturnPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_Calls_Call) { m_duration = (ulong)ReadAndUnpackBits(stream) << Packets.Commands.Bits.CallTimingShift; }
public HeapDumpStartPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_HeapDump_Start) { }
public HeapDumpStopPacket(_DBG.BitStream stream) : base(Commands.c_Profiling_HeapDump_Stop) { m_heapBytesUsed = ReadAndUnpackBits(stream); }