//--------------------------------------------------------------------------
/// Constructor where available layers are pushed.
//--------------------------------------------------------------------------
DX12LayerManager::DX12LayerManager()
: ModernAPILayerManager()
, mInterceptor(NULL)
, mbIsInitialized(false)
{
m_LayerList = (LAYERDESC*) & s_LayerList;
m_LayerListSize = sizeof(s_LayerList) / sizeof(s_LayerList[0]);
// Start with the object database layer enabled, as we want to track object instances from the start.
m_AvailableLayers.push_back(DX12ObjectDatabaseProcessor::Instance());
m_AvailableLayers.push_back(DX12FrameDebuggerLayer::Instance());
// @TODO: Remove this DEBUG code when the client knows how to request the backbuffer image.
// This will stay for now to eliminate the manual step of PushLayer'ing the DX12FrameDebuggerLayer.
DX12FrameDebuggerLayer* frameDebuggerLayer = DX12FrameDebuggerLayer::Instance();
PushLayer(*frameDebuggerLayer, &m_pushLayer);
// If AutoCapture is enabled in the log file, automatically push the TraceAnalyzer to the stack.
bool bPushTraceAnalyzer = (SG_GET_INT(OptionTraceType) != kTraceType_None);
if (bPushTraceAnalyzer)
{
// Add the TraceAnalyzer so it can AutoCapture at a specified frame.
DX12TraceAnalyzerLayer* traceLayer = DX12TraceAnalyzerLayer::Instance();
m_AvailableLayers.push_back(traceLayer);
PushLayer(*traceLayer, &m_pushLayer);
}
}
//-----------------------------------------------------------------------------
/// Constructor where available layers are pushed.
//-----------------------------------------------------------------------------
DX12LayerManager::DX12LayerManager()
: ModernAPILayerManager()
, mInterceptor(nullptr)
, mbIsInitialized(false)
{
m_LayerList = (LAYERDESC*) & s_LayerList;
m_LayerListSize = sizeof(s_LayerList) / sizeof(s_LayerList[0]);
// Start with the object database layer enabled, as we want to track object instances from the start.
m_AvailableLayers.push_back(DX12ObjectDatabaseProcessor::Instance());
m_AvailableLayers.push_back(DX12FrameDebuggerLayer::Instance());
m_AvailableLayers.push_back(DX12TraceAnalyzerLayer::Instance());
// If AutoCapture is enabled in the config file, automatically push the TraceAnalyzer to the stack.
bool bPushTraceAnalyzer = (SG_GET_INT(OptionTraceType) != kTraceType_None);
if (bPushTraceAnalyzer)
{
// Add the TraceAnalyzer so it can AutoCapture at a specified frame.
DX12TraceAnalyzerLayer* traceLayer = DX12TraceAnalyzerLayer::Instance();
PushLayer(*traceLayer, &m_pushLayer);
}
osFilePath logFilePath;
logFilePath.setPath(osFilePath::OS_TEMP_DIRECTORY);
char fullPath[PS_MAX_PATH] = {};
sprintf(fullPath, "%s\\%s\\GPS", logFilePath.asString().asASCIICharArray(), GetPerfStudioDirName());
mStreamLog.SetBaseNamePath(fullPath);
}
void SnippingWindow::OnRender()
{
if (screenshot != nullptr)
{
auto fullRect = D2D1::RectF(0.f, 0.f,
PixelsToDipsX<float>(resolutionX),
PixelsToDipsY<float>(resolutionY));
auto rt = GetRenderTarget();
rt->DrawBitmap(screenshot, fullRect);
rt->PushLayer(D2D1::LayerParameters(),
topLayer);
rt->FillRectangle(fullRect, whiteBrush);
rt->PopLayer();
rt->PushLayer(D2D1::LayerParameters(toolbarCtrl->manager->RectangleToShot), shownLayer);
rt->DrawBitmap(screenshot, fullRect);
rt->PopLayer();
}
}
nsresult TransportFlow::PushLayers(std::queue<TransportLayer *> layers) {
nsresult rv;
while (!layers.empty()) {
rv = PushLayer(layers.front());
layers.pop();
if (NS_FAILED(rv)) {
// Destroy any layers we could not push.
while (!layers.empty()) {
delete layers.front();
layers.pop();
}
return rv;
}
}
return NS_OK;
}
PRIntn main(PRIntn argc, char **argv)
{
PRStatus rv;
PRIntn mits;
PLOptStatus os;
PRFileDesc *client, *service;
PRFileDesc *client_stack, *service_stack;
PRNetAddr any_address;
const char *server_name = NULL;
const PRIOMethods *stubMethods;
PRThread *client_thread, *server_thread;
PRThreadScope thread_scope = PR_LOCAL_THREAD;
PLOptState *opt = PL_CreateOptState(argc, argv, "dqGC:c:p:");
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
{
if (PL_OPT_BAD == os) continue;
switch (opt->option)
{
case 0:
server_name = opt->value;
break;
case 'd': /* debug mode */
if (verbosity < noisy)
verbosity = ChangeVerbosity(verbosity, 1);
break;
case 'q': /* debug mode */
if (verbosity > silent)
verbosity = ChangeVerbosity(verbosity, -1);
break;
case 'G': /* use global threads */
thread_scope = PR_GLOBAL_THREAD;
break;
case 'C': /* number of threads waiting */
major_iterations = atoi(opt->value);
break;
case 'c': /* number of client threads */
minor_iterations = atoi(opt->value);
break;
case 'p': /* default port */
default_port = atoi(opt->value);
break;
default:
break;
}
}
PL_DestroyOptState(opt);
PR_STDIO_INIT();
logFile = PR_GetSpecialFD(PR_StandardError);
identity = PR_GetUniqueIdentity("Dummy");
stubMethods = PR_GetDefaultIOMethods();
/*
** The protocol we're going to implement is one where in order to initiate
** a send, the sender must first solicit permission. Therefore, every
** send is really a send - receive - send sequence.
*/
myMethods = *stubMethods; /* first get the entire batch */
myMethods.recv = MyRecv; /* then override the ones we care about */
myMethods.send = MySend; /* then override the ones we care about */
if (NULL == server_name)
rv = PR_InitializeNetAddr(
PR_IpAddrLoopback, default_port, &server_address);
else
{
rv = PR_StringToNetAddr(server_name, &server_address);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_InitializeNetAddr(
PR_IpAddrNull, default_port, &server_address);
}
PR_ASSERT(PR_SUCCESS == rv);
/* one type w/o layering */
mits = minor_iterations;
while (major_iterations-- > 0)
{
if (verbosity > silent)
PR_fprintf(logFile, "Beginning non-layered test\n");
client = PR_NewTCPSocket(); PR_ASSERT(NULL != client);
service = PR_NewTCPSocket(); PR_ASSERT(NULL != service);
rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv);
minor_iterations = mits;
server_thread = PR_CreateThread(
PR_USER_THREAD, Server, service,
PR_PRIORITY_HIGH, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != server_thread);
client_thread = PR_CreateThread(
PR_USER_THREAD, Client, client,
PR_PRIORITY_NORMAL, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != client_thread);
rv = PR_JoinThread(client_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_JoinThread(server_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(client); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(service); PR_ASSERT(PR_SUCCESS == rv);
if (verbosity > silent)
PR_fprintf(logFile, "Ending non-layered test\n");
/* with layering */
if (verbosity > silent)
PR_fprintf(logFile, "Beginning layered test\n");
client = PR_NewTCPSocket(); PR_ASSERT(NULL != client);
PushLayer(client);
service = PR_NewTCPSocket(); PR_ASSERT(NULL != service);
PushLayer(service);
rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv);
minor_iterations = mits;
server_thread = PR_CreateThread(
PR_USER_THREAD, Server, service,
PR_PRIORITY_HIGH, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != server_thread);
client_thread = PR_CreateThread(
PR_USER_THREAD, Client, client,
PR_PRIORITY_NORMAL, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != client_thread);
rv = PR_JoinThread(client_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_JoinThread(server_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(client); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(service); PR_ASSERT(PR_SUCCESS == rv);
/* with layering, using new style stack */
if (verbosity > silent)
PR_fprintf(logFile,
"Beginning layered test with new style stack\n");
client = PR_NewTCPSocket(); PR_ASSERT(NULL != client);
client_stack = PR_CreateIOLayer(client);
PushNewLayers(client_stack);
service = PR_NewTCPSocket(); PR_ASSERT(NULL != service);
service_stack = PR_CreateIOLayer(service);
PushNewLayers(service_stack);
rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv);
minor_iterations = mits;
server_thread = PR_CreateThread(
PR_USER_THREAD, Server, service_stack,
PR_PRIORITY_HIGH, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != server_thread);
client_thread = PR_CreateThread(
PR_USER_THREAD, Client, client_stack,
PR_PRIORITY_NORMAL, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != client_thread);
rv = PR_JoinThread(client_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_JoinThread(server_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(client_stack); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(service_stack); PR_ASSERT(PR_SUCCESS == rv);
if (verbosity > silent)
PR_fprintf(logFile, "Ending layered test\n");
}
return 0;
} /* main */
//--------------------------------------------------------------------------
/// Begin the frame.
//--------------------------------------------------------------------------
void ModernAPILayerManager::BeginFrame()
{
GetPendingRequests();
if (mCmdSetSessionName.IsActive())
{
gtASCIIString sessionName = mCmdSetSessionName.GetValue();
if (SessionManager::Instance()->SetSessionName(sessionName) == false)
{
mCmdSetSessionName.Send("Failed");
}
else
{
mCmdSetSessionName.Send("OK");
}
}
if (mCmdSetProjectName.IsActive())
{
gtASCIIString projectName = mCmdSetProjectName.GetValue();
if (SessionManager::Instance()->SetProjectName(projectName) == false)
{
mCmdSetProjectName.Send("Failed");
}
else
{
mCmdSetProjectName.Send("OK");
}
}
// Check if we need to collect a trace for this currently-rendering frame.
if (mbTraceTriggeredFromKeypress)
{
Log(logMESSAGE, "Keypress capture starting.\n");
MultithreadedTraceAnalyzerLayer* traceAnalyzer = GetTraceAnalyzerLayer();
if (traceAnalyzer != nullptr)
{
// Examine the layer stack to check for any enabled layers. If there are,
// we won't be able to collect a trace successfully.
if (m_EnabledLayers.empty())
{
#if ENABLE_CLIENT_LOCKOUT_ON_KEYPRESS
// Tell the GPUPerfServer to reject all incoming requests (it will send the stalled status return to all messages)
SG_SET_BOOL(ForceRenderStallState, true);
#endif // ENABLE_CLIENT_LOCKOUT_ON_KEYPRESS
// Since there aren't any layers enabled in the stack, we can proceed with pushing the Logger.
if (!traceAnalyzer->IsEnabled())
{
// Need to add the TraceAnalyzer layer to the stack.
PushLayer(*traceAnalyzer, &m_pushLayer);
}
// Enable trace collection for the next rendered frame.
traceAnalyzer->EnableLinkedTraceCollection();
}
else
{
// The LayerManager's "enabled layer stack" wasn't empty, meaning the client was in the middle of an operation.
// Dump a message to the log, and forget that a keypress trace was requested.
Log(logMESSAGE, "Layer stack is non-empty. Not going to push the Logger for Keypress Capture.\n");
mbTraceTriggeredFromKeypress = false;
}
}
}
if (mCmdFrameCaptureWithSave.IsActive())
{
// Extract the capture mode argument from the capture mode string
m_captureType = (CaptureType)mCmdFrameCaptureWithSave.GetCaptureType();
m_captureCount = mCmdFrameCaptureWithSave.GetCaptureCount();
if (m_captureCount == 0)
{
Log(logERROR, "ModernAPILayerManager::BeginFrame - m_captureCount is 0, forcing it to 1.\n");
m_captureCount = 1;
}
// Exclude Frame Capture
if (m_captureType > 0 && m_captureType < 4)
{
// Now I need to make sure that the MultithreadedTraceAnalyzerLayer is on the stack.
MultithreadedTraceAnalyzerLayer* traceAnalyzer = GetTraceAnalyzerLayer();
traceAnalyzer->EnableLinkedTraceCollection();
// enable objectInspector writing to disk
ObjectDatabaseProcessor* objectDatabase = GetObjectDatabaseProcessor();
objectDatabase->EnableObjectDatabaseCollection();
}
}
// Call into the base class to deal with basic layer management.
LayerManager::BeginFrame();
}
void UILayerManager::PushLayer(const VeChar8* pcName, const UIUserDataPtr& spUserData)
{
PushLayer(GetLayer(pcName), spUserData);
}
void UILayerManager::PushLayer(const VeChar8* pcName)
{
PushLayer(pcName, NULL);
}
void CSDLStateHandler::NewLayerDelayedClear( CSDLObjectQueueList* pLayer )
{
bNewLayerNextFrame = true;
PushLayer( pLayer );
}
void CSDLStateHandler::NewLayer( CSDLObjectQueueList* pLayer )
{
ClearLayers();
PushLayer( pLayer );
}
