tf2/tf2_src/utils/vmpi/vmpi_distribute_tracker.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================//

#include <windows.h>
#include <conio.h>
#include <io.h>
#include "vmpi.h"
#include "vmpi_distribute_work.h"
#include "tier0/platform.h"
#include "tier0/dbg.h"
#include "utlvector.h"
#include "utllinkedlist.h"


#define EVENT_TYPE_SEND_WORK_UNIT	0
#define EVENT_TYPE_WU_STARTED		1
#define EVENT_TYPE_WU_COMPLETED		2

class CWorkUnitEvent
{
public:
	int m_iEventType;	// EVENT_TYPE_ define.
	int m_iWorker;
	double m_flTime;
};


class CWorkUnit
{
public:
	CWorkUnit()
	{
		m_iWorkerCompleted = -1;
	}
	
	int m_iWorkerCompleted;	// Which worker completed this work unit (-1 if not done yet).
	
	CUtlVector<CWorkUnitEvent> m_Events;
};


static CUtlVector<CWorkUnit> g_WorkUnits;
static double g_flJobStartTime;
static bool g_bTrackWorkUnitEvents = false;


static int CountActiveWorkUnits()
{
	int nActive = 0;
	for ( int i=0; i < g_WorkUnits.Count(); i++ )
	{
		if ( g_WorkUnits[i].m_iWorkerCompleted == -1 )
			++nActive;
	}
	return nActive;
}


// ------------------------------------------------------------------------ //
// Graphical functions.
// ------------------------------------------------------------------------ //

static bool g_bUseGraphics = false;
static HWND g_hWnd = 0;

static int g_LastSizeX = 600, g_LastSizeY = 600;

static COLORREF g_StateColors[] =
{
	RGB(50,50,50),
	RGB(100,0,0),
	RGB(150,0,0),
	RGB(0,155,0),
	RGB(0,255,0),
	RGB(0,0,150),
	RGB(0,0,250)
};

static HANDLE g_hCreateEvent = 0;
static HANDLE g_hDestroyWindowEvent = 0;
static HANDLE g_hDestroyWindowCompletedEvent = 0;

static CRITICAL_SECTION g_CS;

class CWUStatus
{
public:
	CWUStatus()
	{
		m_iState = 0;
		memset( &m_Rect, 0, sizeof( m_Rect ) );
	}
	
	RECT m_Rect;
	int m_iState;				// 0 = not sent yet
								// 1 = sent, 2 = sent recently
								// 3 = done, 4 = done recently
								// 5 = started, 6 = started recently
	float m_flTransitionTime;
};
CUtlVector<CWUStatus> g_WUStatus;
int g_nChanges = 0;
int g_nLastDrawnChanges = -1;

static LRESULT CALLBACK TrackerWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	switch( uMsg )
	{
		case WM_PAINT:
		{
			// Do one pass for each color..
			HBRUSH hStateColors[ARRAYSIZE( g_StateColors )];
			for ( int i=0; i < ARRAYSIZE( hStateColors ); i++ )
				hStateColors[i] = CreateSolidBrush( g_StateColors[i] );

			// Copy the WU statuses.
			CUtlVector<CWUStatus> wuStatus;
			EnterCriticalSection( &g_CS );

			g_nLastDrawnChanges = g_nChanges;
			wuStatus.SetSize( g_WUStatus.Count() );
			memcpy( wuStatus.Base(), g_WUStatus.Base(), wuStatus.Count() * sizeof( wuStatus[0] ) );

			LeaveCriticalSection( &g_CS );

			PAINTSTRUCT ps;
			HDC hDC = BeginPaint( hwnd, &ps );		
			for ( int iState=0; iState < ARRAYSIZE( hStateColors ); iState++ )
			{
				HGDIOBJ hOldObj = SelectObject( hDC, hStateColors[iState] );

				for ( int iWU=0; iWU < wuStatus.Count(); iWU++ )
				{
					if ( wuStatus[iWU].m_iState != iState )
						continue;
					
					RECT &rc = wuStatus[iWU].m_Rect;
					Rectangle( hDC, rc.left, rc.top, rc.right, rc.bottom );
				}
				
				SelectObject( hDC, hOldObj );
				DeleteObject( hStateColors[iState] );
			}
			EndPaint( hwnd, &ps );
		}
		break;
		
		case WM_SIZE:
		{
			int width = LOWORD( lParam );
			int height = HIWORD( lParam );
			
			g_LastSizeX = width;
			g_LastSizeY = height;
			
			// Figure out the rectangles for everything.
			int nWorkUnits = g_WUStatus.Count();
			
			// What is the max width of the grid elements so they will fit in the width and height.
			int testSize;
			for ( testSize=20; testSize > 1; testSize-- )
			{
				int nX = width / testSize;
				int nY = height / testSize;
				if ( nX * nY >= nWorkUnits )
					break;
			}
			static int minTestSize = 3;
			testSize = max( testSize, minTestSize );
			
			int xPos=0, yPos=0;
			for ( int i=0; i < nWorkUnits; i++ )
			{
				g_WUStatus[i].m_Rect.left = xPos;
				g_WUStatus[i].m_Rect.top = yPos;
				g_WUStatus[i].m_Rect.right = xPos + testSize;
				g_WUStatus[i].m_Rect.bottom = yPos + testSize;
				
				xPos += testSize;
				if ( (xPos+testSize) > width )
				{
					yPos += testSize;
					xPos = 0;
				}
			}
		}
		break;
	}
	
	return DefWindowProc( hwnd, uMsg, wParam, lParam );
}

static void CheckFlashTimers()
{
	double flCurTime = Plat_FloatTime();

	EnterCriticalSection( &g_CS );

	// Check timers for the events that just happened (we show them in a brighter color if they just occurred).
	for ( int iWU=0; iWU < g_WUStatus.Count(); iWU++ )
	{
		CWUStatus &s = g_WUStatus[iWU];
		
		if ( s.m_iState == 2 || s.m_iState == 4 || s.m_iState == 6 )
		{
			if ( flCurTime > s.m_flTransitionTime )
			{
				s.m_iState -= 1;
				++g_nChanges;
			}
		}
	}

	LeaveCriticalSection( &g_CS );
}

static DWORD WINAPI ThreadProc( LPVOID lpParameter )
{
	// Create the window.
	const char *pClassName = "VMPI_Tracker";

	// Register the application
	WNDCLASSEX WndClsEx;
	WndClsEx.cbSize        = sizeof(WNDCLASSEX);
	WndClsEx.style         = CS_HREDRAW | CS_VREDRAW;
	WndClsEx.lpfnWndProc   = TrackerWindowProc;
	WndClsEx.cbClsExtra    = 0;
	WndClsEx.cbWndExtra    = 0;
	WndClsEx.hIcon         = NULL;
	WndClsEx.hCursor       = LoadCursor(NULL, IDC_ARROW);
	WndClsEx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	WndClsEx.lpszMenuName  = NULL;
	WndClsEx.lpszClassName = pClassName;
	WndClsEx.hInstance     = (HINSTANCE)GetCurrentProcess();
	WndClsEx.hIconSm       = NULL;
	RegisterClassEx(&WndClsEx);
	
	// Create the window.
	g_hWnd = CreateWindow( 
		pClassName,
		"VMPI Tracker",
		WS_OVERLAPPEDWINDOW,
		0, 0, g_LastSizeX, g_LastSizeY,
		NULL, NULL,
		(HINSTANCE)GetCurrentProcess(),
		NULL );

	ShowWindow( g_hWnd, SW_SHOW );
	
	// Tell the main thread we're ready.
	SetEvent( g_hCreateEvent );
	
	// Run our main loop.
	while ( WaitForSingleObject( g_hDestroyWindowEvent, 200 ) != WAIT_OBJECT_0 )
	{
		MSG msg;
		while ( PeekMessage( &msg, g_hWnd, 0, 0, PM_REMOVE ) )
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg); 
		}

		CheckFlashTimers();
				
		if ( g_nChanges != g_nLastDrawnChanges )
			InvalidateRect( g_hWnd, NULL, FALSE );
	}
	
	// Tell the main thread we're done.	
	SetEvent( g_hDestroyWindowCompletedEvent );
	return 0;
}

static void Graphical_Start()
{
	g_bUseGraphics = VMPI_IsParamUsed( mpi_Graphics );
	if ( !g_bUseGraphics )
		return;
	
	// Setup an event so we'll wait until the window is ready.
	if ( !g_hCreateEvent )
	{
		g_hCreateEvent = CreateEvent( 0, 0, 0, 0 );
		g_hDestroyWindowEvent = CreateEvent( 0, 0, 0, 0 );
		g_hDestroyWindowCompletedEvent = CreateEvent( 0, 0, 0, 0 );
		InitializeCriticalSection( &g_CS );
	}
	ResetEvent( g_hCreateEvent );
	ResetEvent( g_hDestroyWindowCompletedEvent );

	g_WUStatus.SetSize( g_WorkUnits.Count() );
	for ( int i=0; i < g_WUStatus.Count(); i++ )
		g_WUStatus[i].m_iState = 0;
	
	// Setup our thread.
	CreateThread( NULL, 0, ThreadProc, NULL, 0, NULL );
	
	// Wait until the event is signaled.
	WaitForSingleObject( g_hCreateEvent, INFINITE );
}

static void Graphical_WorkUnitSentToWorker( int iWorkUnit )
{
	if ( !g_bUseGraphics )
		return;
	
	EnterCriticalSection( &g_CS );
	
	CWUStatus &s = g_WUStatus[iWorkUnit];
	if ( s.m_iState != 3 && s.m_iState != 4 && s.m_iState != 5 && s.m_iState != 6 )
	{
		s.m_iState = 2;
		s.m_flTransitionTime = Plat_FloatTime() + 0.1f;
		++g_nChanges;
	}
	
	LeaveCriticalSection( &g_CS );
}

static void Graphical_WorkUnitStarted( int iWorkUnit )
{
	if ( !g_bUseGraphics )
		return;
	
	EnterCriticalSection( &g_CS );
	
	if ( g_WUStatus[iWorkUnit].m_iState != 3 && g_WUStatus[iWorkUnit].m_iState != 4 )
	{
		g_WUStatus[iWorkUnit].m_iState = 6;
		g_WUStatus[iWorkUnit].m_flTransitionTime = Plat_FloatTime() + 0.1f;
		++g_nChanges;
	}
	
	LeaveCriticalSection( &g_CS );
}

static void Graphical_WorkUnitCompleted( int iWorkUnit )
{
	if ( !g_bUseGraphics )
		return;
		
	EnterCriticalSection( &g_CS );
	g_WUStatus[iWorkUnit].m_iState = 4;
	g_WUStatus[iWorkUnit].m_flTransitionTime = Plat_FloatTime() + 0.1f;
	++g_nChanges;
	LeaveCriticalSection( &g_CS );
}

static void Graphical_End()
{
	if ( !g_bUseGraphics )
		return;
		
	SetEvent( g_hDestroyWindowEvent );
	WaitForSingleObject( g_hDestroyWindowCompletedEvent, INFINITE );
}


// ------------------------------------------------------------------------ //
// Interface functions.
// ------------------------------------------------------------------------ //

void VMPITracker_Start( int nWorkUnits )
{
	g_bTrackWorkUnitEvents = (VMPI_IsParamUsed( mpi_TrackEvents ) || VMPI_IsParamUsed( mpi_Graphics ));
	g_flJobStartTime = Plat_FloatTime();
	g_WorkUnits.Purge();

	if ( g_bTrackWorkUnitEvents )
	{
		g_WorkUnits.SetSize( nWorkUnits );
	}

	Graphical_Start();
}


void VMPITracker_WorkUnitSentToWorker( int iWorkUnit, int iWorker )
{
	if ( g_bTrackWorkUnitEvents )
	{
		CWorkUnitEvent event;
		event.m_iEventType = EVENT_TYPE_SEND_WORK_UNIT;
		event.m_iWorker = iWorker;
		event.m_flTime = Plat_FloatTime();
		g_WorkUnits[iWorkUnit].m_Events.AddToTail( event );
	}

	Graphical_WorkUnitSentToWorker( iWorkUnit );
}


void VMPITracker_WorkUnitStarted( int iWorkUnit, int iWorker )
{
	if ( g_bTrackWorkUnitEvents )
	{
		CWorkUnitEvent event;
		event.m_iEventType = EVENT_TYPE_WU_STARTED;
		event.m_iWorker = iWorker;
		event.m_flTime = Plat_FloatTime();
		g_WorkUnits[iWorkUnit].m_Events.AddToTail( event );
	}

	Graphical_WorkUnitStarted( iWorkUnit );
}


void VMPITracker_WorkUnitCompleted( int iWorkUnit, int iWorker )
{
	if ( g_bTrackWorkUnitEvents )
	{
		CWorkUnitEvent event;
		event.m_iEventType = EVENT_TYPE_WU_COMPLETED;
		event.m_iWorker = iWorker;
		event.m_flTime = Plat_FloatTime();
		g_WorkUnits[iWorkUnit].m_Events.AddToTail( event );
		g_WorkUnits[iWorkUnit].m_iWorkerCompleted = iWorker;
	}

	Graphical_WorkUnitCompleted( iWorkUnit );
}


void VMPITracker_End()
{
	g_WorkUnits.Purge();
	Graphical_End();
}


bool VMPITracker_WriteDebugFile( const char *pFilename )
{
	FILE *fp = fopen( pFilename, "wt" );
	if ( fp )
	{
		fprintf( fp, "# work units: %d\n", g_WorkUnits.Count() );
		fprintf( fp, "# active work units: %d\n", CountActiveWorkUnits() );
		
		fprintf( fp, "\n" );
		fprintf( fp, "--- Events ---" );
		fprintf( fp, "\n" );
		fprintf( fp, "\n" );
		
		for ( int i=0; i < g_WorkUnits.Count(); i++ )
		{
			CWorkUnit *wu = &g_WorkUnits[i];
			
			if ( wu->m_iWorkerCompleted != -1 )
				continue;

			fprintf( fp, "  work unit %d\n", i );
			fprintf( fp, "\n" );
						
			if ( wu->m_Events.Count() == 0 )
			{
				fprintf( fp, "    *no events*\n" );
			}
			else
			{
				for ( int iEvent=0; iEvent < wu->m_Events.Count(); iEvent++ )
				{
					CWorkUnitEvent *pEvent = &wu->m_Events[iEvent];
					
					if ( pEvent->m_iEventType == EVENT_TYPE_WU_STARTED )
					{
						fprintf( fp, "   started (by worker %s) %.1f seconds ago\n", 
							VMPI_GetMachineName( wu->m_Events[iEvent].m_iWorker ),
							Plat_FloatTime() - wu->m_Events[iEvent].m_flTime );
					}
					else if ( pEvent->m_iEventType == EVENT_TYPE_SEND_WORK_UNIT )
					{
						fprintf( fp, "      sent (to worker %s) %.1f seconds ago\n", 
							VMPI_GetMachineName( wu->m_Events[iEvent].m_iWorker ),
							Plat_FloatTime() - wu->m_Events[iEvent].m_flTime );
					}
					else if ( pEvent->m_iEventType == EVENT_TYPE_WU_COMPLETED )
					{
						fprintf( fp, " completed (by worker %s) %.1f seconds ago\n", 
							VMPI_GetMachineName( wu->m_Events[iEvent].m_iWorker ),
							Plat_FloatTime() - wu->m_Events[iEvent].m_flTime );
					}
				}
			}
			fprintf( fp, "\n" );
		}
		
		fclose( fp );
		return true;
	}
	else
	{
		return false;
	}	
}


void VMPITracker_HandleDebugKeypresses()
{
	if ( !g_bTrackWorkUnitEvents )
		return;
	
	if ( !kbhit() )
		return;

	static int iState = 0;

	int key = toupper( getch() );
	if ( iState == 0 )
	{
		if ( key == 'D' )
		{
			iState = 1;
			Warning("\n\n"
				"----------------------\n"
				"1. Write debug file (ascending filenames).\n"
				"2. Write debug file (c:\\vmpi_tracker_0.txt).\n"
				"3. Invite debug workers (password: 'debugworker').\n"
				"\n"
				"0. Exit menu.\n"
				"----------------------\n"
				"\n"
				);
		}
	}
	else if ( iState == 1 )
	{
		if ( key == '1' )
		{
			iState = 0;
			
			int nMaxTries = 128;
			char filename[512];
			int iFile = 1;
			for ( iFile; iFile < nMaxTries; iFile++ )
			{
				Q_snprintf( filename, sizeof( filename ), "c:\\vmpi_tracker_%d.txt", iFile );
				if ( _access( filename, 0 ) != 0 )
					break;
			}
			if ( iFile == nMaxTries )
			{
				Warning( "** Please delete c:\\vmpi_tracker_*.txt and try again.\n" );
			}
			else
			{
				if ( VMPITracker_WriteDebugFile( filename ) )
					Warning( "Wrote %s successfully.\n", filename );
				else
					Warning( "Failed to write %s successfully.\n", filename );
			}
		}
		else if ( key == '2' )
		{
			iState = 0;

			const char *filename = "c:\\vmpi_tracker_0.txt";
			if ( VMPITracker_WriteDebugFile( filename ) )
				Warning( "Wrote %s successfully.\n", filename );
			else
				Warning( "Failed to write %s successfully.\n", filename );
		}
		else if ( key == '3' )
		{
			iState = 0;
			Warning( "\nInviting debug workers with password 'debugworker'...\nGo ahead and connect them.\n" );
			VMPI_InviteDebugWorkers();
		}
		else if ( key == '0' )
		{
			iState = 0;
			Warning( "\n\nExited menu.\n\n" );
		}
	}
}