int CScreensaver::count_active_graphic_apps(RESULTS& res, RESULT* exclude) { int i = 0; unsigned int graphics_app_count = 0; // Count the number of active graphics-capable apps excluding the specified result. // If exclude is NULL, don't exclude any results. // for (i = res.results.size()-1; i >=0 ; i--) { BOINCTRACE(_T("count_active_graphic_apps -- active task detected\n")); BOINCTRACE( _T("count_active_graphic_apps -- name = '%s', path = '%s'\n"), res.results[i]->name, res.results[i]->graphics_exec_path ); if (!strlen(res.results[i]->graphics_exec_path)) continue; if (is_same_task(res.results[i], exclude)) continue; #ifdef __APPLE__ // Remove it from the vector if incompatible with current version of OS X if (isIncompatible(res.results[i]->graphics_exec_path)) { BOINCTRACE( _T("count_active_graphic_apps -- removing incompatible name = '%s', path = '%s'\n"), res.results[i]->name, res.results[i]->graphics_exec_path ); RESULT *rp = res.results[i]; res.results.erase(res.results.begin()+i); delete rp; continue; } #endif BOINCTRACE(_T("count_active_graphic_apps -- active task detected w/graphics\n")); graphics_app_count++; } return graphics_app_count; }
int CScreensaver::count_active_graphic_apps(RESULTS& results, RESULT* exclude) { unsigned int i = 0; unsigned int graphics_app_count = 0; m_bV5_GFX_app_is_running = false; // Count the number of active graphics-capable apps excluding the specified result. // If exclude is NULL, don't exclude any results. for (i = 0; i < results.results.size(); i++) { BOINCTRACE(_T("get_random_graphics_app -- active task detected\n")); BOINCTRACE( _T("get_random_graphics_app -- name = '%s', path = '%s'\n"), results.results[i]->name, results.results[i]->graphics_exec_path ); if (results.results[i]->supports_graphics) m_bV5_GFX_app_is_running = true; if (!strlen(results.results[i]->graphics_exec_path) && (state.executing_as_daemon || !(results.results[i]->supports_graphics)) ) { continue; } BOINCTRACE(_T("get_random_graphics_app -- active task detected w/graphics\n")); if (is_same_task(results.results[i], exclude)) continue; graphics_app_count++; } return graphics_app_count; }
// Choose a random graphics application out of the vector. // Exclude the specified result unless it is the only candidate. // If exclude is NULL or an empty string, don't exclude any results. // RESULT* CScreensaver::get_random_graphics_app( RESULTS& res, RESULT* exclude ) { RESULT* rp = NULL; unsigned int i = 0; unsigned int graphics_app_count = 0; unsigned int random_selection = 0; unsigned int current_counter = 0; RESULT *avoid = exclude; BOINCTRACE(_T("get_random_graphics_app -- Function Start\n")); graphics_app_count = count_active_graphic_apps(res, avoid); BOINCTRACE(_T("get_random_graphics_app -- graphics_app_count = '%d'\n"), graphics_app_count); // If no graphics app found other than the one excluded, count again without excluding any if ((0 == graphics_app_count) && (avoid != NULL)) { avoid = NULL; graphics_app_count = count_active_graphic_apps(res, avoid); } // If no graphics app was found, return NULL if (0 == graphics_app_count) { goto CLEANUP; } // Choose which application to display. // random_selection = (rand() % graphics_app_count) + 1; BOINCTRACE(_T("get_random_graphics_app -- random_selection = '%d'\n"), random_selection); // find the chosen graphics application. // for (i = 0; i < res.results.size(); i++) { if (!strlen(res.results[i]->graphics_exec_path)) continue; if (is_same_task(res.results[i], avoid)) continue; current_counter++; if (current_counter == random_selection) { rp = res.results[i]; break; } } CLEANUP: BOINCTRACE(_T("get_random_graphics_app -- Function End\n")); return rp; }
int CScreensaver::count_active_graphic_apps(RESULTS& res, RESULT* exclude) { unsigned int i = 0; unsigned int graphics_app_count = 0; // Count the number of active graphics-capable apps excluding the specified result. // If exclude is NULL, don't exclude any results. // for (i = 0; i < res.results.size(); i++) { BOINCTRACE(_T("get_random_graphics_app -- active task detected\n")); BOINCTRACE( _T("get_random_graphics_app -- name = '%s', path = '%s'\n"), res.results[i]->name, res.results[i]->graphics_exec_path ); if (!strlen(res.results[i]->graphics_exec_path)) continue; if (is_same_task(res.results[i], exclude)) continue; BOINCTRACE(_T("get_random_graphics_app -- active task detected w/graphics\n")); graphics_app_count++; } return graphics_app_count; }
DataMgmtProcType CScreensaver::DataManagementProc() { int retval = 0; int suspend_reason = 0; RESULT* theResult = NULL; RESULT* graphics_app_result_ptr = NULL; RESULT previous_result; // previous_result_ptr = &previous_result when previous_result is valid, else NULL RESULT* previous_result_ptr = NULL; int iResultCount = 0; int iIndex = 0; double default_phase_start_time = 0.0; double science_phase_start_time = 0.0; double last_change_time = 0.0; // If we run default screensaver during science phase because no science graphics // are available, then shorten next default graphics phase by that much time. double default_saver_start_time_in_science_phase = 0.0; double default_saver_duration_in_science_phase = 0.0; SS_PHASE ss_phase = DEFAULT_SS_PHASE; bool switch_to_default_gfx = false; bool killing_default_gfx = false; int exit_status = 0; char* default_ss_dir_path = NULL; char full_path[1024]; BOINCTRACE(_T("CScreensaver::DataManagementProc - Display screen saver loading message\n")); SetError(TRUE, SCRAPPERR_BOINCSCREENSAVERLOADING); // No GFX App is running: show moving BOINC logo #ifdef _WIN32 m_tThreadCreateTime = time(0); // Set the starting point for iterating through the results m_iLastResultShown = 0; m_tLastResultChangeTime = 0; #endif m_bDefault_ss_exists = false; m_bScience_gfx_running = false; m_bDefault_gfx_running = false; m_bShow_default_ss_first = false; #ifdef __APPLE__ m_vIncompatibleGfxApps.clear(); default_ss_dir_path = "/Library/Application Support/BOINC Data"; #else default_ss_dir_path = (char*)m_strBOINCInstallDirectory.c_str(); #endif strlcpy(full_path, default_ss_dir_path, sizeof(full_path)); strlcat(full_path, PATH_SEPARATOR, sizeof(full_path)); strlcat(full_path, THE_DEFAULT_SS_EXECUTABLE, sizeof(full_path)); if (boinc_file_exists(full_path)) { m_bDefault_ss_exists = true; } else { SetError(TRUE, SCRAPPERR_CANTLAUNCHDEFAULTGFXAPP); // No GFX App is running: show moving BOINC logo } if (m_bDefault_ss_exists && m_bShow_default_ss_first) { ss_phase = DEFAULT_SS_PHASE; default_phase_start_time = dtime(); science_phase_start_time = 0; switch_to_default_gfx = true; } else { ss_phase = SCIENCE_SS_PHASE; default_phase_start_time = 0; science_phase_start_time = dtime(); } while (true) { for (int i = 0; i < 4; i++) { // *** // *** Things that should be run frequently. // *** 4 times per second. // *** // Are we supposed to exit the screensaver? if (m_bQuitDataManagementProc) { // If main thread has requested we exit BOINCTRACE(_T("CScreensaver::DataManagementProc - Thread told to stop\n")); if (m_hGraphicsApplication || graphics_app_result_ptr) { if (m_bDefault_gfx_running) { BOINCTRACE(_T("CScreensaver::DataManagementProc - Terminating default screensaver\n")); terminate_default_screensaver(m_hGraphicsApplication); } else { BOINCTRACE(_T("CScreensaver::DataManagementProc - Terminating screensaver\n")); terminate_screensaver(m_hGraphicsApplication, graphics_app_result_ptr); } graphics_app_result_ptr = NULL; previous_result_ptr = NULL; m_hGraphicsApplication = 0; } BOINCTRACE(_T("CScreensaver::DataManagementProc - Stopping...\n")); m_bDataManagementProcStopped = true; // Tell main thread that we exited return 0; // Exit the thread } boinc_sleep(0.25); } // *** // *** Things that should be run less frequently. // *** 1 time per second. // *** // Blank screen saver? if ((m_dwBlankScreen) && (time(0) > m_dwBlankTime) && (m_dwBlankTime > 0)) { BOINCTRACE(_T("CScreensaver::DataManagementProc - Time to blank\n")); SetError(FALSE, SCRAPPERR_SCREENSAVERBLANKED); // Blanked - hide moving BOINC logo m_bQuitDataManagementProc = true; continue; // Code above will exit the thread } BOINCTRACE(_T("CScreensaver::DataManagementProc - ErrorMode = '%d', ErrorCode = '%x'\n"), m_bErrorMode, m_hrError); if (!m_bConnected) { HandleRPCError(); } if (m_bConnected) { // Do we need to get the core client state? if (m_bResetCoreState) { // Try and get the current state of the CC retval = rpc->get_state(state); if (retval) { // CC may not yet be running HandleRPCError(); continue; } else { m_bResetCoreState = false; } } // Update our task list retval = rpc->get_screensaver_tasks(suspend_reason, results); if (retval) { // rpc call returned error HandleRPCError(); m_bResetCoreState = true; continue; } } else { results.clear(); } // Time to switch to default graphics phase? if (m_bDefault_ss_exists && (ss_phase == SCIENCE_SS_PHASE) && (m_fGFXDefaultPeriod > 0)) { if (science_phase_start_time && ((dtime() - science_phase_start_time) > m_fGFXSciencePeriod)) { if (!m_bDefault_gfx_running) { switch_to_default_gfx = true; } ss_phase = DEFAULT_SS_PHASE; default_phase_start_time = dtime(); science_phase_start_time = 0; if (m_bDefault_gfx_running && default_saver_start_time_in_science_phase) { // Remember how long default graphics ran during science phase default_saver_duration_in_science_phase += (dtime() - default_saver_start_time_in_science_phase); } default_saver_start_time_in_science_phase = 0; } } // Time to switch to science graphics phase? if ((ss_phase == DEFAULT_SS_PHASE) && m_bConnected && (m_fGFXSciencePeriod > 0)) { if (default_phase_start_time && ((dtime() - default_phase_start_time + default_saver_duration_in_science_phase) > m_fGFXDefaultPeriod)) { // BOINCTRACE(_T("CScreensaver::Ending Default phase: now=%f, default_phase_start_time=%f, default_saver_duration_in_science_phase=%f\n"), // dtime(), default_phase_start_time, default_saver_duration_in_science_phase); ss_phase = SCIENCE_SS_PHASE; default_phase_start_time = 0; default_saver_duration_in_science_phase = 0; science_phase_start_time = dtime(); if (m_bDefault_gfx_running) { default_saver_start_time_in_science_phase = science_phase_start_time; } switch_to_default_gfx = false; } } // Core client suspended? // We ignore SUSPEND_REASON_CPU_USAGE in SS coordinator, so it won't kill graphics apps for // short-term CPU usage spikes (such as anti-virus.) Added 9 April 2010 if (suspend_reason && !(suspend_reason & (SUSPEND_REASON_CPU_THROTTLE | SUSPEND_REASON_CPU_USAGE))) { if (!m_bDefault_gfx_running) { SetError(TRUE, m_hrError); // No GFX App is running: show moving BOINC logo if (m_bDefault_ss_exists) { switch_to_default_gfx = true; } } } if (switch_to_default_gfx) { if (m_bScience_gfx_running) { if (m_hGraphicsApplication || previous_result_ptr) { // use previous_result_ptr because graphics_app_result_ptr may no longer be valid terminate_screensaver(m_hGraphicsApplication, previous_result_ptr); if (m_hGraphicsApplication == 0) { graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; } else { // HasProcessExited() test will clear m_hGraphicsApplication and graphics_app_result_ptr } previous_result_ptr = NULL; } } else { if (!m_bDefault_gfx_running) { switch_to_default_gfx = false; retval = launch_default_screensaver(default_ss_dir_path, m_hGraphicsApplication); if (retval) { m_hGraphicsApplication = 0; previous_result_ptr = NULL; graphics_app_result_ptr = NULL; m_bDefault_gfx_running = false; SetError(TRUE, SCRAPPERR_CANTLAUNCHDEFAULTGFXAPP); // No GFX App is running: show moving BOINC logo } else { m_bDefault_gfx_running = true; if (ss_phase == SCIENCE_SS_PHASE) { default_saver_start_time_in_science_phase = dtime(); } SetError(FALSE, SCRAPPERR_BOINCSCREENSAVERLOADING); // A GFX App is running: hide moving BOINC logo } } } } if ((ss_phase == SCIENCE_SS_PHASE) && !switch_to_default_gfx) { #if SIMULATE_NO_GRAPHICS /* FOR TESTING */ if (!m_bDefault_gfx_running) { SetError(TRUE, m_hrError); // No GFX App is running: show moving BOINC logo if (m_bDefault_ss_exists) { switch_to_default_gfx = true; } } #else /* NORMAL OPERATION */ if (m_bScience_gfx_running) { // Is the current graphics app's associated task still running? if ((m_hGraphicsApplication) || (graphics_app_result_ptr)) { iResultCount = (int)results.results.size(); graphics_app_result_ptr = NULL; // Find the current task in the new results vector (if it still exists) for (iIndex = 0; iIndex < iResultCount; iIndex++) { theResult = results.results.at(iIndex); if (is_same_task(theResult, previous_result_ptr)) { graphics_app_result_ptr = theResult; previous_result = *theResult; previous_result_ptr = &previous_result; break; } } // V6 graphics only: if worker application has stopped running, terminate_screensaver if ((graphics_app_result_ptr == NULL) && (m_hGraphicsApplication != 0)) { if (previous_result_ptr) { BOINCTRACE(_T("CScreensaver::DataManagementProc - %s finished\n"), previous_result.graphics_exec_path ); } terminate_screensaver(m_hGraphicsApplication, previous_result_ptr); previous_result_ptr = NULL; if (m_hGraphicsApplication == 0) { graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; // Save previous_result and previous_result_ptr for get_random_graphics_app() call } else { // HasProcessExited() test will clear m_hGraphicsApplication and graphics_app_result_ptr } } if (last_change_time && (m_fGFXChangePeriod > 0) && ((dtime() - last_change_time) > m_fGFXChangePeriod) ) { if (count_active_graphic_apps(results, previous_result_ptr) > 0) { if (previous_result_ptr) { BOINCTRACE(_T("CScreensaver::DataManagementProc - time to change: %s / %s\n"), previous_result.name, previous_result.graphics_exec_path ); } terminate_screensaver(m_hGraphicsApplication, graphics_app_result_ptr); if (m_hGraphicsApplication == 0) { graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; // Save previous_result and previous_result_ptr for get_random_graphics_app() call } else { // HasProcessExited() test will clear m_hGraphicsApplication and graphics_app_result_ptr } } last_change_time = dtime(); } } } // End if (m_bScience_gfx_running) // If no current graphics app, pick an active task at random // and launch its graphics app // if ((m_bDefault_gfx_running || (m_hGraphicsApplication == 0)) && (graphics_app_result_ptr == NULL)) { if (suspend_reason && !(suspend_reason & (SUSPEND_REASON_CPU_THROTTLE | SUSPEND_REASON_CPU_USAGE))) { graphics_app_result_ptr = NULL; } else { graphics_app_result_ptr = get_random_graphics_app(results, previous_result_ptr); previous_result_ptr = NULL; } if (graphics_app_result_ptr) { if (m_bDefault_gfx_running) { terminate_default_screensaver(m_hGraphicsApplication); killing_default_gfx = true; // Remember how long default graphics ran during science phase if (default_saver_start_time_in_science_phase) { default_saver_duration_in_science_phase += (dtime() - default_saver_start_time_in_science_phase); //BOINCTRACE(_T("CScreensaver::During Science phase: now=%f, default_saver_start_time=%f, default_saver_duration=%f\n"), // dtime(), default_saver_start_time_in_science_phase, default_saver_duration_in_science_phase); } default_saver_start_time_in_science_phase = 0; // HasProcessExited() test will clear // m_hGraphicsApplication and graphics_app_result_ptr } else { retval = launch_screensaver(graphics_app_result_ptr, m_hGraphicsApplication); if (retval) { m_hGraphicsApplication = 0; previous_result_ptr = NULL; graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; } else { // A GFX App is running: hide moving BOINC logo // SetError(FALSE, SCRAPPERR_BOINCSCREENSAVERLOADING); last_change_time = dtime(); m_bScience_gfx_running = true; // Make a local copy of current result, since original pointer // may have been freed by the time we perform later tests previous_result = *graphics_app_result_ptr; previous_result_ptr = &previous_result; if (previous_result_ptr) { BOINCTRACE(_T("CScreensaver::DataManagementProc - launching %s\n"), previous_result.graphics_exec_path ); } } } } else { if (!m_bDefault_gfx_running) { // We can't run a science graphics app, so run the default graphics if available SetError(TRUE, m_hrError); if (m_bDefault_ss_exists) { switch_to_default_gfx = true; } } } // End if no science graphics available } // End if no current science graphics app is running #endif // ! SIMULATE_NO_GRAPHICS if (switch_to_default_gfx) { switch_to_default_gfx = false; if (!m_bDefault_gfx_running) { retval = launch_default_screensaver(default_ss_dir_path, m_hGraphicsApplication); if (retval) { m_hGraphicsApplication = 0; previous_result_ptr = NULL; graphics_app_result_ptr = NULL; m_bDefault_gfx_running = false; SetError(TRUE, SCRAPPERR_CANTLAUNCHDEFAULTGFXAPP); // No GFX App is running: show BOINC logo } else { m_bDefault_gfx_running = true; default_saver_start_time_in_science_phase = dtime(); SetError(FALSE, SCRAPPERR_BOINCSCREENSAVERLOADING); // Default GFX App is running: hide moving BOINC logo } } } } // End if ((ss_phase == SCIENCE_SS_PHASE) && !switch_to_default_gfx) // Is the graphics app still running? if (m_hGraphicsApplication) { if (HasProcessExited(m_hGraphicsApplication, exit_status)) { // Something has happened to the previously selected screensaver // application. Start a different one. BOINCTRACE(_T("CScreensaver::DataManagementProc - Graphics application isn't running, start a new one.\n")); if (m_bDefault_gfx_running) { // If we were able to connect to core client // but gfx app can't, don't use it. // BOINCTRACE(_T("CScreensaver::DataManagementProc - Default graphics application exited with code %d.\n"), exit_status); if (!killing_default_gfx) { // If this is an unexpected exit if (exit_status == DEFAULT_GFX_CANT_CONNECT) { SetError(TRUE, SCRAPPERR_DEFAULTGFXAPPCANTCONNECT); // No GFX App is running: show moving BOINC logo } else { SetError(TRUE, SCRAPPERR_DEFAULTGFXAPPCRASHED); // No GFX App is running: show moving BOINC logo } m_bDefault_ss_exists = false; ss_phase = SCIENCE_SS_PHASE; } killing_default_gfx = false; } SetError(TRUE, SCRAPPERR_BOINCNOGRAPHICSAPPSEXECUTING); // No GFX App is running: show moving BOINC logo m_hGraphicsApplication = 0; graphics_app_result_ptr = NULL; m_bDefault_gfx_running = false; m_bScience_gfx_running = false; #ifdef __APPLE__ launchedGfxApp("", 0, -1); #endif continue; } } } // end while(true) }