public MemorySpacePoint AddMemoryAllocation(uint address, int size, int startIndex, int endIndex) { var startPoint = MemorySpacePoint.GeneratePoint(address, size); startPoint.StartIndex = startIndex; startPoint.EndPoint.StartIndex = startIndex; startPoint.EndIndex = endIndex; startPoint.EndPoint.EndIndex = endIndex; // debug test if (RegisteredSpace.Any(s => s.StartPoint.Address == address && s.EndPoint.Address == address + size)) { var duplicateSpace = RegisteredSpace.First(s => s.StartPoint.Address == address && s.EndPoint.Address == address + size); Debug.Log("Adding duplicate space!"); MemorySpacePoint container; var isContained = IsAccessContained(startPoint, startPoint.EndPoint, out container); } AddSpace(startPoint, startPoint.EndPoint); return(startPoint); }
public MemorySpacePoint AddMemoryAllocation(uint address, int size) { var startPoint = MemorySpacePoint.GeneratePoint(address, size); AddSpace(startPoint, startPoint.RelatedPoint); return(startPoint); }
public static MemorySpacePoint GeneratePoint(uint address, int size) { var newPoint = new MemorySpacePoint(address, true); var endPoint = new MemorySpacePoint(address + (uint)size, false); newPoint.RelatedPoint = endPoint; endPoint.RelatedPoint = newPoint; return(newPoint); }
public void AddSpace(MemorySpacePoint startPoint, MemorySpacePoint endPoint) { if (RegisteredSpace.Count == 0) { RegisteredSpace.Add(startPoint); RegisteredSpace.Add(endPoint); return; } BinaryInsertPoint(startPoint); BinaryInsertPoint(endPoint); }
public bool IsAccessContained(MemorySpacePoint accessStart, MemorySpacePoint accessEnd, out MemorySpacePoint containingSpace) { containingSpace = null; //List<MemorySpacePoint> containingRegions = new List< MemorySpacePoint >(); int startRegions = BinarySearchIndex(accessStart.Address); if (startRegions > RegisteredSpace.Count - 1) { return(false); } for (int i = startRegions - 1; i >= 0; i--) { var testRegion = RegisteredSpace[i]; if (testRegion.IsEnd) { continue; } if (testRegion.EndPoint.Address < accessEnd.Address) { continue; } if (accessStart.StartIndex < testRegion.StartIndex) { continue; } if (accessStart.EndIndex > testRegion.EndIndex) { continue; } containingSpace = testRegion; return(true); } return(false); }
public override IEnumerator ReceivePayload(VisualPayload payload) { //var outOfBoundsColor = OutOfBoundsColor.GetFirstValue( payload.Data ); var outOfBoundsReadColor = OutOfBoundsReadColor.GetFirstValue(payload.Data); var outOfBoundsWriteColor = OutOfBoundsWriteColor.GetFirstValue(payload.Data); var allocatedAlpha = AllocationAlpha.GetFirstValue(payload.Data); var valueStepSize = ValueStepSize.GetFirstValue(payload.Data); var allocationColor = AllocationColor.GetFirstValue(payload.Data); float allocH, allocS, allocV; ColorUtility.RGBToHSV(allocationColor, out allocH, out allocS, out allocV); //var readWriteDifferentiation = ReadWriteDifferentiation.GetFirstValue( payload.Data ); foreach (var entry in TraceScope.GetEntries(payload.Data)) { var memSpace = new MemorySpace(); //var saturation = Saturation.GetValue( entry ); //var hueStep = HueStepSize.GetValue( entry ); //var value = Value.GetValue( entry ); int maxIndex = MaxIndex.GetValue(entry); // match allocations and frees var allocations = new Dictionary <uint, MemorySpacePoint>(); foreach (var allocation in AllocateScope.GetEntries(entry)) { var address = AllocateAddress.GetValue(allocation); var size = AllocateSize.GetValue(allocation); var index = AllocateIndex.GetValue(allocation); var newPoint = memSpace.AddMemoryAllocation(address, size); newPoint.StartIndex = index; newPoint.EndPoint.StartIndex = index; newPoint.EndIndex = maxIndex; newPoint.EndPoint.EndIndex = maxIndex; allocations.Add(newPoint.Address, newPoint); } // assign the end indices of any allocates with matched frees foreach (var free in FreeScope.GetEntries(entry)) { var index = FreeIndex.GetValue(free); var address = FreeAddress.GetValue(free); if (allocations.ContainsKey(address)) { var matchedAllocation = allocations[address]; matchedAllocation.EndIndex = index; matchedAllocation.EndPoint.EndIndex = index; } } // import reads to the memory space var readPoints = new Dictionary <int, MemorySpacePoint>(); foreach (var read in ReadScope.GetEntries(entry)) { var address = ReadAddress.GetValue(read); var size = ReadSize.GetValue(read); var index = ReadIndex.GetValue(read); var readPoint = MemorySpacePoint.GeneratePoint(address, size); readPoint.AllIndices = index; MemorySpacePoint containingPoint; if (memSpace.IsAccessContained(readPoint, readPoint.EndPoint, out containingPoint)) { readPoint.ContainingAllocation = containingPoint; } else { var outOfBoundsAlloc = memSpace.AddMemoryAllocation(address, size, 0, maxIndex); outOfBoundsAlloc.IsOutOfBounds = true; readPoint.ContainingAllocation = outOfBoundsAlloc; } readPoints.Add(index, readPoint); } // import Writes to the memory space var writePoints = new Dictionary <int, MemorySpacePoint>(); foreach (var write in WriteScope.GetEntries(entry)) { var address = WriteAddress.GetValue(write); var size = WriteSize.GetValue(write); var index = WriteIndex.GetValue(write); var writePoint = MemorySpacePoint.GeneratePoint(address, size); writePoint.AllIndices = index; MemorySpacePoint containingPoint; if (memSpace.IsAccessContained(writePoint, writePoint.EndPoint, out containingPoint)) { writePoint.ContainingAllocation = containingPoint; } else { var outOfBoundsAlloc = memSpace.AddMemoryAllocation(address, size, 0, maxIndex); outOfBoundsAlloc.IsOutOfBounds = true; writePoint.ContainingAllocation = outOfBoundsAlloc; } writePoints.Add(index, writePoint); } // generate visual space for memory allocations (include out of bounds allocations) memSpace.SetVisualBounding(); // set colors for memory allocations (inclde out of bounds allocations with special color) //var hueRotor = HueStart.GetValue( entry ); foreach (var allocation in memSpace.RegisteredSpace.Where(s => s.IsStart)) { Color nextColor = ColorUtility.HsvtoRgb(allocH, allocS, allocV); allocV = .3f + (allocV + valueStepSize) % .7f; /*(allocation.IsOutOfBounds)? * outOfBoundsColor: * ColorUtility.HsvtoRgb(hueRotor, saturation, * value);*/ nextColor.a = allocatedAlpha; //if ( !allocation.IsOutOfBounds ) // hueRotor += hueStep; allocation.VisualColor = nextColor; } // set colors and visual locations for all reads foreach (var read in readPoints) { if (read.Value.ContainingAllocation == null) { Debug.LogError("Danger will robinson! Danger!"); } read.Value.VisualColor = outOfBoundsReadColor; // read.Value.ContainingAllocation.VisualColor == outOfBoundsColor? // outOfBoundsReadColor: // Color.Lerp( // read.Value.ContainingAllocation.VisualColor, // Color.white, readWriteDifferentiation); //read.Value.VisualStart = memSpace.AddressToVisualPosition( read.Value.Address ); //read.Value.VisualEnd = memSpace.AddressToVisualPosition( read.Value.EndPoint.Address ); read.Value.ComputeVisualPositionsFromContainer(); } // set colors and visual locations for all writes foreach (var write in writePoints) { if (write.Value.ContainingAllocation == null) { Debug.LogError("Danger will robinson! Danger!"); } write.Value.VisualColor = outOfBoundsWriteColor; // write.Value.ContainingAllocation.VisualColor == outOfBoundsColor? // outOfBoundsWriteColor: // Color.Lerp( // write.Value.ContainingAllocation.VisualColor, // Color.black, readWriteDifferentiation); write.Value.ComputeVisualPositionsFromContainer(); //write.Value.VisualStart = memSpace.AddressToVisualPosition(write.Value.Address); //write.Value.VisualEnd = memSpace.AddressToVisualPosition(write.Value.EndPoint.Address); } // FINALLY, write this information into the corresponding targets foreach (var allocation in AllocateScope.GetEntries(entry)) { var targetAddress = AllocateAddress.GetValue(allocation); //var targetIndex = AllocateIndex.GetValue( allocation ); if (!allocations.ContainsKey(targetAddress)) { throw new Exception("Allocation address not found!"); } var foundAllocation = allocations[targetAddress]; AllocateColorTarget.SetValue(foundAllocation.VisualColor, allocation); AllocatePositionTarget.SetValue(foundAllocation.VisualStart, allocation); AllocateSizeTarget.SetValue(foundAllocation.VisualEnd - foundAllocation.VisualStart, allocation); AllocateEndIndexTarget.SetValue(foundAllocation.EndIndex, allocation); } foreach (var read in ReadScope.GetEntries(entry)) { var targetIndex = ReadIndex.GetValue(read); if (!readPoints.ContainsKey(targetIndex)) { throw new Exception("Read index not found!"); } var foundRead = readPoints[targetIndex]; ReadColorTarget.SetValue(foundRead.VisualColor, read); ReadPositionTarget.SetValue(foundRead.VisualStart, read); ReadSizeTarget.SetValue(foundRead.VisualEnd - foundRead.VisualStart, read); } foreach (var write in WriteScope.GetEntries(entry)) { var targetIndex = WriteIndex.GetValue(write); if (!writePoints.ContainsKey(targetIndex)) { throw new Exception("Write index not found!"); continue; } var foundwrite = writePoints[targetIndex]; WriteColorTarget.SetValue(foundwrite.VisualColor, write); WritePositionTarget.SetValue(foundwrite.VisualStart, write); WriteSizeTarget.SetValue(foundwrite.VisualEnd - foundwrite.VisualStart, write); } // write grid lines var gridLines = new List <MutableObject>(); uint priorAddress = memSpace.RegisteredSpace.First().Address; gridLines.Add(new MutableObject { { "Visual Position", 0f }, { "Visual Weight", 1000f } }); foreach (var space in memSpace.RegisteredSpace) { if (space.IsEnd) { continue; } var newGridLine = new MutableObject { { "Visual Position", space.VisualStart }, { "Visual Weight", (float)(Mathf.Max(0, priorAddress - space.StartPoint.Address) + 1) } }; priorAddress = space.EndPoint.Address; gridLines.Add(newGridLine); } gridLines.Add(new MutableObject { { "Visual Position", 1f }, { "Visual Weight", 1000f } }); GridLinesTarget.SetValue(gridLines, entry); } var iterator = Router.TransmitAll(payload); while (iterator.MoveNext()) { yield return(null); } }
private void BinaryInsertPoint(MemorySpacePoint point) { RegisteredSpace.Insert(BinarySearchIndex(point.Address), point); }