CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plStatGather/plCalculatedProfiles.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "plProfile.h"
#include "plProfileManager.h"
#include "plNetClient/plNetClientMgr.h"
#include "hsTimer.h"

plProfile_CreateCounter("Age Upload BitsPerSec", "Network", UploadAgeBitsPerSec);
plProfile_CreateMemCounter("Upload Bytes", "Network", UploadBW);
plProfile_CreateMemCounter("Upload Avg Packet Size", "Network", UploadAPS);
plProfile_CreateCounter("Upload Num Packets", "Network", UploadPPS);
plProfile_CreateCounter("Upload Avg Packets Queued", "Network", UploadPQ);
plProfile_CreateCounter("Recvd Multiple Acks", "Network", RMultAcksPQ);

plProfile_CreateCounter("Age Download BitsPerSec", "Network", DownloadAgeBitsPerSec);
plProfile_CreateMemCounter("Download Bytes", "Network", DownloadBW);
plProfile_CreateMemCounter("Download Avg Packet Size", "Network", DownloadAPS);
plProfile_CreateCounter("Download Num Packets", "Network", DownloadPPS);
plProfile_CreateCounter("Download Avg Packets Queued", "Network", DownloadPQ);
plProfile_CreateCounter("Download Dropped Pkts", "Network", DownloadDP);

plProfile_CreateCounter("Remote Players", "Network", RemotePlayers);
plProfile_CreateCounter("Peers", "Network", Peers);
plProfile_CreateCounter("Player ID", "Network", PlayerID);
plProfile_CreateCounter("Account ID", "Network", AccountID);

plProfile_CreateTimer("Avg Receipt Time", "Network", AvgReceiptTime);
plProfile_CreateTimer("Peak Receipt Time", "Network", PeakReceiptTime);

#ifdef HS_FIND_MEM_LEAKS
plProfile_CreateMemCounter("Allocated", "Memory", MemAllocated);
plProfile_CreateMemCounter("Peak Alloc", "Memory", MemPeakAlloc);
#endif

static plProfileVar gVarRFPS("RFPS", "General", plProfileVar::kDisplayTime | plProfileVar::kDisplayFPS);

plProfile_Extern(DrawTriangles);
plProfile_Extern(MatChange);
plProfile_CreateCounter("Polys Per Material", "General", PolysPerMat);

#ifdef PL_PROFILE_ENABLED
#define plProfile_GetValue(varName) gProfileVar##varName.GetValue()
#else
#define plProfile_GetValue(varName) 0
#endif

void CalculateProfiles()
{
	// KLUDGE - do timing that overlaps the beginframe / endframe (where timing is normally reset)
	static UInt32 lastTicks = plProfileManager::GetTime();
	UInt32 curTicks = plProfileManager::GetTime();
	gVarRFPS.Set(curTicks - lastTicks);
	lastTicks = curTicks;

	// KLUDGE - calulate the polys per material
	if (plProfile_GetValue(MatChange) == 0)
		plProfile_Set(PolysPerMat, 0);
	else
		plProfile_Set(PolysPerMat, plProfile_GetValue(DrawTriangles) / plProfile_GetValue(MatChange));

	#ifdef HS_FIND_MEM_LEAKS
//	plProfile_Set(MemAllocated, MemGetAllocated());
//	plProfile_Set(MemPeakAlloc, MemGetPeakAllocated());
	#endif

	// Network stats
	plNetClientMgr* nc = plNetClientMgr::GetInstance();
	if (!nc->GetFlagsBit(plNetClientMgr::kDisabled))
	{
#if 0
		hsAssert(nc->GetNetCore(), "nil net core in stats?");
		plNetCoreStats* ns = nc->GetNetCore()->GetStats();

		plProfile_Set(UploadAgeBitsPerSec, (UInt32)nc->GetNetClientStats().GetAgeStatsULBitsPerSec());
		plProfile_Set(UploadBW, ns->GetULBits()/8);
		plProfile_Set(UploadPPS, ns->GetULPackets());
		plProfile_Set(UploadAPS, (UInt32)ns->GetULAvgPacketBytes());
		plProfile_Set(UploadPQ, (UInt32)ns->GetULAvgNumPacketsQueued());
		plProfile_Set(RMultAcksPQ, nc->GetNetClientStats().GetRecvdMultipleAcks());

		plProfile_Set(DownloadAgeBitsPerSec, (UInt32)nc->GetNetClientStats().GetAgeStatsDLBitsPerSec());
		plProfile_Set(DownloadBW, ns->GetDLBits()/8);
		plProfile_Set(DownloadPPS, ns->GetDLPackets());
		plProfile_Set(DownloadAPS, (UInt32)ns->GetDLAvgPacketBytes());
		plProfile_Set(DownloadPQ, (UInt32)ns->GetDLAvgNumPacketsQueued());
		plProfile_Set(DownloadDP, ns->GetDLDroppedPackets());

		plProfile_Set(RemotePlayers, nc->RemotePlayerKeys().size());
		plProfile_Set(Peers, ns->GetNumPeers());
		plProfile_Set(PlayerID, nc->GetPlayerID());
		plProfile_Set(AccountID, nc->GetAccountID());

		plProfile_Set(AvgReceiptTime, hsTimer::PrecSecsToTicks(ns->GetAvgReceiptTime()));
		plProfile_Set(PeakReceiptTime, hsTimer::PrecSecsToTicks(ns->GetPeakReceiptTime()));
#endif
	}
}

#include "../plPipeline/plPlates.h"

static plGraphPlate* fFPSPlate = nil;
static plGraphPlate* fNetBWPlate = nil;
static plGraphPlate* fNetPPSPlate = nil;
static plGraphPlate* fNetQueuesPlate = nil;
static plGraphPlate* fNetAvgBWPlate = nil;
static plGraphPlate* fNetAvgPPSPlate = nil;
static plGraphPlate* fNetAvgQueuesPlate = nil;

static int ICreateStdPlate(plGraphPlate** graph)
{
	if (plPlateManager::InstanceValid())
	{
		plPlateManager::Instance().CreateGraphPlate(graph);
		(*graph)->SetSize(0.25, 0.25);
		(*graph)->SetDataRange(0, 100, 100);
		return hsOK;
	}
	return hsFail;
}

void CreateStandardGraphs(const char* groupName, bool create)
{
	if (strcmp(groupName, "General") == 0)
	{
		if (create)
		{
			if (ICreateStdPlate(&fFPSPlate) == hsOK)
			{
				fFPSPlate->SetTitle("mSecs");		
				fFPSPlate->SetLabelText("Tot", "Draw", "Upd");
			}
		}
		else
		{
			plPlateManager::Instance().DestroyPlate(fFPSPlate);
			fFPSPlate = nil;
		}
	}
	else if (strcmp(groupName, "Network") == 0)
	{
		if (create)
		{
			if (ICreateStdPlate(&fNetBWPlate) == hsOK)
			{
				fNetBWPlate->SetDataLabels(0, 2000);
				fNetBWPlate->SetTitle("Bytes");
				fNetBWPlate->SetLabelText("UL", "DL");

				ICreateStdPlate(&fNetPPSPlate);
				fNetPPSPlate->SetDataLabels(0, 20);
				fNetPPSPlate->SetTitle("Packets");
				fNetPPSPlate->SetLabelText("UL", "DL");

				ICreateStdPlate(&fNetQueuesPlate);
				fNetQueuesPlate->SetDataLabels(0, 20);
				fNetQueuesPlate->SetTitle("Queue Counts");
				fNetQueuesPlate->SetLabelText("UL", "DL");

				ICreateStdPlate(&fNetQueuesPlate);
				fNetQueuesPlate->SetDataLabels(0, 20);
				fNetQueuesPlate->SetTitle("Queue Counts");
				fNetQueuesPlate->SetLabelText("UL", "DL");

				ICreateStdPlate(&fNetQueuesPlate);
				fNetQueuesPlate->SetDataLabels(0, 20);
				fNetQueuesPlate->SetTitle("Queue Counts");
				fNetQueuesPlate->SetLabelText("UL", "DL");

				ICreateStdPlate(&fNetAvgBWPlate);
				fNetAvgBWPlate->SetDataLabels(0, 5000);
				fNetAvgBWPlate->SetTitle("Avg BytesPS");
				fNetAvgBWPlate->SetLabelText("UL", "DL");

				ICreateStdPlate(&fNetAvgPPSPlate);
				fNetAvgPPSPlate->SetDataLabels(0, 40);
				fNetAvgPPSPlate->SetTitle("Avg PacketsPS");
				fNetAvgPPSPlate->SetLabelText("UL", "DL");

				ICreateStdPlate(&fNetAvgQueuesPlate);
				fNetAvgQueuesPlate->SetDataLabels(0, 40);
				fNetAvgQueuesPlate->SetTitle("Avg Queue CountsPS");
				fNetAvgQueuesPlate->SetLabelText("UL", "DL");
			}
		}
		else
		{
			plPlateManager::Instance().DestroyPlate(fNetBWPlate);
			plPlateManager::Instance().DestroyPlate(fNetPPSPlate);
			plPlateManager::Instance().DestroyPlate(fNetQueuesPlate);
			plPlateManager::Instance().DestroyPlate(fNetAvgBWPlate);
			plPlateManager::Instance().DestroyPlate(fNetAvgPPSPlate);
			plPlateManager::Instance().DestroyPlate(fNetAvgQueuesPlate);
			fNetBWPlate = nil;
			fNetPPSPlate = nil;
			fNetQueuesPlate = nil;
			fNetAvgBWPlate = nil;
			fNetAvgPPSPlate = nil;
			fNetAvgQueuesPlate = nil;
		}
	}
}

plProfile_CreateTimer("Draw", "General", DrawTime);
plProfile_CreateTimer("Update", "General", UpdateTime);

void UpdateStandardGraphs(float xPos, float yPos)
{
	#define PositionPlate(plate)		\
		plate->SetPosition(xPos, yPos);	\
		yPos += 0.25;					\
		plate->SetVisible(true);

	if (fFPSPlate)
	{
		fFPSPlate->AddData(
			gVarRFPS.GetValue(),
			plProfile_GetValue(DrawTime),
			plProfile_GetValue(UpdateTime));
		PositionPlate(fFPSPlate);
	}

	plNetClientMgr* nc = plNetClientMgr::GetInstance();


#if 0
	plNetCoreStats* ns = nc ? nc->GetNetCore()->GetStats() : nil;

	if (!nc || !ns)
		return;

	if (fNetBWPlate)
	{
		fNetBWPlate->AddData(
			(UInt32)(ns->GetULBits()/8.f),
			(UInt32)(ns->GetDLBits()/8.f));
		PositionPlate(fNetBWPlate);
	}

	if (fNetPPSPlate)
	{
		fNetPPSPlate->AddData(
			ns->GetULPackets(),
			ns->GetDLPackets());
		PositionPlate(fNetPPSPlate);
	}

	if (fNetQueuesPlate)
	{
		unsigned int ul, dl;
		nc->GetNetCore()->GetOutQueueMsgCount(plNetCore::kPeerAll,ul);
		nc->GetNetCore()->GetInQueueMsgCount(plNetCore::kPeerAll,dl);
		fNetQueuesPlate->AddData(ul,dl);
		PositionPlate(fNetQueuesPlate);
	}

	if (fNetAvgBWPlate)
	{
		fNetAvgBWPlate->AddData(
			(UInt32)(ns->GetULBitsPS()/8.f),
			(UInt32)(ns->GetDLBitsPS()/8.f));
		PositionPlate(fNetAvgBWPlate);
	}

	if (fNetAvgPPSPlate)
	{
		fNetAvgPPSPlate->AddData(
			(Int32)ns->GetULNumPacketsPS(),
			(Int32)ns->GetDLNumPacketsPS());
		PositionPlate(fNetAvgPPSPlate);
	}

	if (fNetAvgQueuesPlate)
	{
		fNetAvgQueuesPlate->AddData(
			(Int32)ns->GetULAvgNumPacketsQueued(),
			(Int32)ns->GetDLAvgNumPacketsQueued());
		PositionPlate(fNetAvgQueuesPlate);
	}
#endif

}