//-------------------------------------------------------------------------- /// 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 ); }