override public void OnItemAdded(TokenReplicateActor Item)
{
base.OnItemAdded(Item);
TimeInMS += Item.TimeInMS;
foreach (var Property in Item.Properties)
{
SizeBits += Property.NumBits;
Properties.AddItem(Property, Property.PropertyNameIndex);
}
}
override public void OnItemAdded(TokenReplicateActor Item)
{
base.OnItemAdded(Item);
if (Item.Properties.Count > 0)
{
ReplicatedCount++;
}
TimeInMS += Item.TimeInMS;
foreach (var Property in Item.Properties)
{
SizeBits += Property.NumBits;
Properties.AddItem(Property, Property.PropertyNameIndex);
}
foreach (var PropertyHeader in Item.PropertyHeaders)
{
SizeBits += PropertyHeader.NumBits;
}
}
/**
* Dumps actor/property tokens into a tree view for viewing performance timings
*/
public void ToActorPerformanceView(NetworkStream NetworkStream, TreeView TreeView, string ActorFilter, string PropertyFilter, string RPCFilter)
{
UniqueItemTracker <UniqueActor, TokenReplicateActor> UniqueActors = new UniqueItemTracker <UniqueActor, TokenReplicateActor>();
foreach (TokenBase Token in Tokens)
{
TokenReplicateActor ActorToken = Token as TokenReplicateActor;
if (ActorToken == null)
{
continue;
}
UniqueActors.AddItem(ActorToken, NetworkStream.GetClassNameIndex(ActorToken.ActorNameIndex));
}
var ActorDetailList = UniqueActors.UniqueItems.OrderByDescending(s => s.Value.TimeInMS).ToList();
TreeView.Nodes.Clear();
foreach (var UniqueActor in ActorDetailList)
{
long NumActorBytes = (UniqueActor.Value.SizeBits + 7) / 8;
string ActorStr = string.Format("{0,-32} : {1:0.00} ({2:000}) ({3:000})", NetworkStream.GetName(UniqueActor.Key), UniqueActor.Value.TimeInMS, NumActorBytes, UniqueActor.Value.Count);
TreeView.Nodes.Add(ActorStr);
var PropertyDetailList = UniqueActor.Value.Properties.UniqueItems.OrderByDescending(s => s.Value.SizeBits).ToList();
foreach (var Property in PropertyDetailList)
{
long NumPropBytes = (Property.Value.SizeBits + 7) / 8;
string PropName = NetworkStream.GetName(Property.Key);
string PropStr = string.Format("{0,-25} : {1:000} ({2:000})", PropName, NumPropBytes, Property.Value.Count);
TreeView.Nodes[TreeView.Nodes.Count - 1].Nodes.Add(PropStr);
}
}
}
public string[] ToActorPerformanceString(NetworkStream NetworkStream, string ActorFilter, string PropertyFilter, string RPCFilter)
{
var Details = new List <string>();
UniqueItemTracker <UniqueActor, TokenReplicateActor> UniqueActors = new UniqueItemTracker <UniqueActor, TokenReplicateActor>();
foreach (TokenBase Token in Tokens)
{
TokenReplicateActor ActorToken = Token as TokenReplicateActor;
if (ActorToken == null)
{
continue;
}
UniqueActors.AddItem(ActorToken, NetworkStream.GetClassNameIndex(ActorToken.ActorNameIndex));
}
var ActorDetailList = UniqueActors.UniqueItems.OrderByDescending(s => s.Value.TimeInMS).ToList();
Int32 NumActors = 0;
long NumSentBytes = 0;
float TotalMS = 0.0f;
foreach (var UniqueActor in ActorDetailList)
{
NumActors += UniqueActor.Value.Count;
TotalMS += UniqueActor.Value.TimeInMS;
var PropertyDetailList = UniqueActor.Value.Properties.UniqueItems.OrderByDescending(s => s.Value.SizeBits).ToList();
foreach (var Property in PropertyDetailList)
{
NumSentBytes += (Property.Value.SizeBits + 7) / 8;
}
}
Details.Add("Total Actors : " + NumActors.ToString());
Details.Add("Total MS : " + string.Format("{0:0.00}", TotalMS));
Details.Add("Sent Bytes : " + NumSentBytes.ToString());
foreach (var UniqueActor in ActorDetailList)
{
long NumActorBytes = (UniqueActor.Value.SizeBits + 7) / 8;
string ActorStr = string.Format("{0,-34} : {1:0.00} ({2,4}) ({3,2})", NetworkStream.GetName(UniqueActor.Key), UniqueActor.Value.TimeInMS, NumActorBytes, UniqueActor.Value.Count);
Details.Add(ActorStr);
var PropertyDetailList = UniqueActor.Value.Properties.UniqueItems.OrderByDescending(s => s.Value.SizeBits).ToList();
foreach (var Property in PropertyDetailList)
{
long NumPropBytes = (Property.Value.SizeBits + 7) / 8;
string PropName = NetworkStream.GetName(Property.Key);
string PropStr = string.Format("{0,-22} : {1,4} ({2,2})", PropName, NumPropBytes, Property.Value.Count);
Details.Add(" " + PropStr);
}
Details.Add("-----------------------------------");
}
return(Details.ToArray());
}
protected void UpdateSummary(TokenBase Token, FilterValues InFilterValues)
{
switch (Token.TokenType)
{
case ETokenTypes.FrameMarker:
var TokenFrameMarker = (TokenFrameMarker)Token;
if (StartTime < 0)
{
StartTime = TokenFrameMarker.RelativeTime;
EndTime = TokenFrameMarker.RelativeTime;
}
else
{
EndTime = TokenFrameMarker.RelativeTime;
}
NumFrames++;
break;
case ETokenTypes.SocketSendTo:
var TokenSocketSendTo = (TokenSocketSendTo)Token;
// Unreal game socket
if (TokenSocketSendTo.SocketNameIndex == NameIndexUnreal)
{
UnrealSocketCount++;
UnrealSocketSize += TokenSocketSendTo.BytesSent;
}
else
{
OtherSocketCount++;
OtherSocketSize += TokenSocketSendTo.BytesSent;
}
break;
case ETokenTypes.SendBunch:
var TokenSendBunch = (TokenSendBunch)Token;
SendBunchCount++;
SendBunchSizeBits += TokenSendBunch.GetNumTotalBits();
SendBunchHeaderSizeBits += TokenSendBunch.NumHeaderBits;
int ChannelTypeIndex = TokenSendBunch.GetChannelTypeIndex();
if (SendBunchCountPerChannel.ContainsKey(ChannelTypeIndex))
{
SendBunchCountPerChannel[ChannelTypeIndex]++;
SendBunchSizeBitsPerChannel[ChannelTypeIndex] += TokenSendBunch.GetNumTotalBits();
SendBunchHeaderSizeBitsPerChannel[ChannelTypeIndex] += TokenSendBunch.NumHeaderBits;
SendBunchPayloadSizeBitsPerChannel[ChannelTypeIndex] += TokenSendBunch.NumPayloadBits;
}
else
{
SendBunchCountPerChannel.Add(ChannelTypeIndex, 1);
SendBunchSizeBitsPerChannel.Add(ChannelTypeIndex, TokenSendBunch.GetNumTotalBits());
SendBunchHeaderSizeBitsPerChannel.Add(ChannelTypeIndex, TokenSendBunch.NumHeaderBits);
SendBunchPayloadSizeBitsPerChannel.Add(ChannelTypeIndex, TokenSendBunch.NumPayloadBits);
}
break;
case ETokenTypes.SendRPC:
var TokenSendRPC = (TokenSendRPC)Token;
RPCCount++;
RPCSizeBits += TokenSendRPC.GetNumTotalBits();
break;
case ETokenTypes.ReplicateActor:
var TokenReplicateActor = (TokenReplicateActor)Token;
ActorCount++;
if (TokenReplicateActor.Properties.Count > 0)
{
ReplicatedActorCount++;
}
ActorReplicateTimeInMS += TokenReplicateActor.TimeInMS;
foreach (var Property in TokenReplicateActor.Properties)
{
if (Property.MatchesFilters(InFilterValues))
{
PropertyCount++;
ReplicatedSizeBits += Property.NumBits;
}
}
foreach (var PropertyHeader in TokenReplicateActor.PropertyHeaders)
{
if (PropertyHeader.MatchesFilters(InFilterValues))
{
ReplicatedSizeBits += PropertyHeader.NumBits;
}
}
UniqueActors.AddItem(TokenReplicateActor, TokenReplicateActor.GetClassNameIndex());
break;
case ETokenTypes.Event:
NumEvents++;
break;
case ETokenTypes.RawSocketData:
break;
case ETokenTypes.SendAck:
var TokenSendAck = (TokenSendAck)Token;
SendAckCount++;
SendAckSizeBits += TokenSendAck.NumBits;
break;
case ETokenTypes.ExportBunch:
var TokenExportBunch = (TokenExportBunch)Token;
ExportBunchCount++;
ExportBunchSizeBits += TokenExportBunch.NumBits;
break;
case ETokenTypes.MustBeMappedGuids:
var TokenMustBeMappedGuids = (TokenMustBeMappedGuids)Token;
MustBeMappedGuidCount += TokenMustBeMappedGuids.NumGuids;
MustBeMappedGuidSizeBits += TokenMustBeMappedGuids.NumBits;
break;
case ETokenTypes.BeginContentBlock:
var TokenBeginContentBlock = (TokenBeginContentBlock)Token;
ContentBlockHeaderCount++;
ContentBlockHeaderSizeBits += TokenBeginContentBlock.NumBits;
break;
case ETokenTypes.EndContentBlock:
var TokenEndContentBlock = (TokenEndContentBlock)Token;
ContentBlockFooterCount++;
ContentBlockFooterSizeBits += TokenEndContentBlock.NumBits;
break;
case ETokenTypes.WritePropertyHandle:
var TokenWritePropertyHandle = (TokenWritePropertyHandle)Token;
PropertyHandleCount++;
PropertyHandleSizeBits += TokenWritePropertyHandle.NumBits;
break;
default:
throw new System.IO.InvalidDataException();
}
}
