From e294c3f87630b94043b660c1a3676f4dbef8d133 Mon Sep 17 00:00:00 2001 From: Charlie Fenton Date: Wed, 23 Jul 2008 03:54:49 +0000 Subject: [PATCH] MGR: async GUI RPCs: Begin adding support for all RPCs. svn path=/workspaces/charlief/; revision=15662 --- checkin_notes | 28 ++++++ clientgui/AsyncRPC.cpp | 70 +++++++++---- clientgui/AsyncRPC.h | 223 +++++++++++++++++++++++++++++++++-------- 3 files changed, 261 insertions(+), 60 deletions(-) diff --git a/checkin_notes b/checkin_notes index 7dd3a2a2c7..c2438c7f7f 100644 --- a/checkin_notes +++ b/checkin_notes @@ -5954,3 +5954,31 @@ Charlie 21 July 2008 boinc.xcodeproj/ project.pbxproj +Eric 22 July 2008 + - Implementation of automatic credit leveling for cpu based projects that + wish to use it. + - The script calculate_credit_multiplier (expected to be run daily as + a config.xml task) looks at the ratio of granted credit to CPU time + for recent results for each app. Multiplier is calculated to cause + median hosts granted credit per cpu second to equal to equal that + expected from its benchmarks. This is 30-day exponentially averaged + with the previous value of the multplier and stored in the table + credit_multplier. + - When a result is received the server adjusts claimed credit by the + value the multiplier had when the result was sent. + + tools/ + calculate_credit_multiplier + db/ + boinc_db.[Ch] + db/ + schema.sql + sched/ + sched_util.[Ch] + sched_result.C + +Charlie 22 July 2008 + - MGR: async GUI RPCs: Begin adding support for all RPCs. + + clientgui/ + AsyncRPC.cpp,.h diff --git a/clientgui/AsyncRPC.cpp b/clientgui/AsyncRPC.cpp index e896e47518..1da6ea7925 100644 --- a/clientgui/AsyncRPC.cpp +++ b/clientgui/AsyncRPC.cpp @@ -45,9 +45,11 @@ ASYNC_RPC_REQUEST::~ASYNC_RPC_REQUEST() { void ASYNC_RPC_REQUEST::clear() { which_rpc = (RPC_SELECTOR) 0; - inBuf = NULL; + arg1 = NULL; exchangeBuf = NULL; - outBuf = NULL; + arg2 = NULL; + arg3 = NULL; + arg4 = NULL; event = NULL; eventHandler = NULL; completionTime = NULL; @@ -57,9 +59,11 @@ void ASYNC_RPC_REQUEST::clear() { bool ASYNC_RPC_REQUEST::isSameAs(ASYNC_RPC_REQUEST& otherRequest) { if (which_rpc != otherRequest.which_rpc) return false; - if (inBuf != otherRequest.inBuf) return false; + if (arg1 != otherRequest.arg1) return false; if (exchangeBuf != otherRequest.exchangeBuf) return false; - if (outBuf != otherRequest.outBuf) return false; + if (arg2 != otherRequest.arg2) return false; + if (arg3 != otherRequest.arg3) return false; + if (arg4 != otherRequest.arg4) return false; if (event != otherRequest.event) { if (event->GetEventType() != (otherRequest.event)->GetEventType()) return false; if (event->GetId() != (otherRequest.event)->GetId()) return false; @@ -72,6 +76,29 @@ bool ASYNC_RPC_REQUEST::isSameAs(ASYNC_RPC_REQUEST& otherRequest) { } +AsyncRPC::AsyncRPC(CMainDocument *pDoc) { + m_Doc = pDoc; +} + + +AsyncRPC::~AsyncRPC() {} + + +int AsyncRPC::RPC_Wait(RPC_SELECTOR which_rpc, void *arg1, void *arg2, void *arg3, void *arg4) { + ASYNC_RPC_REQUEST request; + int retval = 0; + + request.which_rpc = which_rpc; + request.arg1 = arg1; + request.arg2 = arg2; + request.arg3 = arg3; + request.arg4 = arg4; + + retval = m_Doc->RequestRPC(request); + return retval; +} + + RPCThread::RPCThread(CMainDocument *pDoc) : wxThread() { m_Doc = pDoc; @@ -132,22 +159,22 @@ int RPCThread::ProcessRPCRequest() { ASYNC_RPC_REQUEST *current_request; current_request = m_Doc->GetCurrentRPCRequest(); -Sleep(5000); // TEMPORARY FOR TESTING ASYNC RPCs -- CAF +//Sleep(5000); // TEMPORARY FOR TESTING ASYNC RPCs -- CAF switch (current_request->which_rpc) { case RPC_GET_STATE: - if (current_request->inBuf == NULL) return -1; - retval = (m_Doc->rpc).get_state((CC_STATE&)*(CC_STATE*)(current_request->inBuf)); + if (current_request->arg1 == NULL) return -1; + retval = (m_Doc->rpc).get_state((CC_STATE&)*(CC_STATE*)(current_request->arg1)); break; case RPC_GET_RESULTS: - if (current_request->inBuf == NULL) return -1; + if (current_request->arg1 == NULL) return -1; // TODO: Confirm if the following is correct - retval = (m_Doc->rpc).get_results((RESULTS&)*(RESULTS*)(current_request->inBuf)); + retval = (m_Doc->rpc).get_results((RESULTS&)*(RESULTS*)(current_request->arg1)); break; case RPC_GET_ALL_PROJECTS_LIST: - if (current_request->inBuf == NULL) return -1; - retval = (m_Doc->rpc).get_all_projects_list((ALL_PROJECTS_LIST&)*(ALL_PROJECTS_LIST*)(current_request->inBuf)); + if (current_request->arg1 == NULL) return -1; + retval = (m_Doc->rpc).get_all_projects_list((ALL_PROJECTS_LIST&)*(ALL_PROJECTS_LIST*)(current_request->arg1)); break; default: break; @@ -328,26 +355,27 @@ void CMainDocument::OnRPCComplete(CRPCFinishedEvent& event) { m_iGet_state_RPC_retval = retval; #if 0 if (completed_RPC_requests[i].exchangeBuf) { - CC_STATE* inBuf = (CC_STATE*)completed_RPC_requests[i].inBuf; + CC_STATE* arg1 = (CC_STATE*)completed_RPC_requests[i].arg1; CC_STATE* exchangeBuf = (CC_STATE*)completed_RPC_requests[i].exchangeBuf; - inBuf->results.swap(exchangeBuf->results); + arg1->results.swap(exchangeBuf->results); } #endif break; case RPC_GET_RESULTS: m_iGet_results_RPC_retval = retval; if (completed_RPC_requests[i].exchangeBuf) { - RESULTS* inBuf = (RESULTS*)completed_RPC_requests[i].inBuf; + RESULTS* arg1 = (RESULTS*)completed_RPC_requests[i].arg1; RESULTS* exchangeBuf = (RESULTS*)completed_RPC_requests[i].exchangeBuf; - inBuf->results.swap(exchangeBuf->results); + arg1->results.swap(exchangeBuf->results); } break; case RPC_GET_ALL_PROJECTS_LIST: // m_iGet_all_projects_list_RPC_retval = retval; +m_iGet_state_RPC_retval = retval; // TEMPORARY FOR TESTING ASYNC RPCs -- CAF if (completed_RPC_requests[i].exchangeBuf) { - ALL_PROJECTS_LIST* inBuf = (ALL_PROJECTS_LIST*)completed_RPC_requests[i].inBuf; + ALL_PROJECTS_LIST* arg1 = (ALL_PROJECTS_LIST*)completed_RPC_requests[i].arg1; ALL_PROJECTS_LIST* exchangeBuf = (ALL_PROJECTS_LIST*)completed_RPC_requests[i].exchangeBuf; - inBuf->projects.swap(exchangeBuf->projects); + arg1->projects.swap(exchangeBuf->projects); } break; default: @@ -452,9 +480,11 @@ void CMainDocument::TestAsyncRPC() { // TEMPORARY FOR TESTING ASYNC RPCs completionTime.ResetTime(); request.which_rpc = RPC_GET_ALL_PROJECTS_LIST; - request.inBuf = &pl; + request.arg1 = &pl; request.exchangeBuf = NULL; - request.outBuf = NULL; + request.arg2 = NULL; + request.arg3 = NULL; + request.arg4 = NULL; request.event = NULL; request.eventHandler = NULL; request.completionTime = &completionTime; @@ -467,5 +497,7 @@ void CMainDocument::TestAsyncRPC() { // TEMPORARY FOR TESTING ASYNC RPCs wxString s = completionTime.FormatTime(); wxLogMessage(wxT("Completion time = %s"), s.c_str()); wxLogMessage(wxT("RequestRPC returned %d\n"), retval); + ::wxSafeYield(NULL, true); // Allow processing of RPC_FINISHED event + wxLogMessage(wxT("rpc.get_all_projects_list returned %d\n"), m_iGet_state_RPC_retval); } diff --git a/clientgui/AsyncRPC.h b/clientgui/AsyncRPC.h index aa9f8dafec..f7fb3e8fbb 100644 --- a/clientgui/AsyncRPC.h +++ b/clientgui/AsyncRPC.h @@ -38,59 +38,68 @@ class CMainDocument; // Forward declaration enum RPC_SELECTOR { - RPC_INIT_POLL = 1, - RPC_AUTHORIZE, - RPC_INIT_ASYNCH, + RPC_AUTHORIZE = 1, RPC_EXCHANGE_VERSIONS, RPC_GET_STATE, - RPC_GET_HOST_INFO, - RPC_GET_CC_STATUS, - RPC_GET_PROJECT_STATUS, RPC_GET_RESULTS, - RPC_GET_MESSAGES, RPC_GET_FILE_TRANSFERS, + RPC_GET_SIMPLE_GUI_INFO1, + RPC_GET_SIMPLE_GUI_INFO2, + RPC_GET_PROJECT_STATUS1, + RPC_GET_PROJECT_STATUS2, + RPC_GET_ALL_PROJECTS_LIST, RPC_GET_DISK_USAGE, - RPC_GET_STATISTICS, - RPC_GET_PROXY_SETTINGS, - RPC_GET_SIMPLE_GUI_INFO, + RPC_SHOW_GRAPHICS, + RPC_PROJECT_OP, RPC_SET_RUN_MODE, RPC_SET_NETWORK_MODE, + RPC_GET_SCREENSAVER_TASKS, RPC_RUN_BENCHMARKS, - RPC_QUIT, RPC_SET_PROXY_SETTINGS, - RPC_PROJECT_OP, - RPC_RESULT_OP, - RPC_SHOW_GRAPHICS, + RPC_GET_PROXY_SETTINGS, + RPC_GET_MESSAGES, RPC_FILE_TRANSFER_OP, - RPC_ACCT_MGR_RPC, - RPC_ACCT_MGR_RPC_POLL, - RPC_GET_PROJECT_CONFIG, - RPC_GET_PROJECT_CONFIG_POLL, + RPC_RESULT_OP, + RPC_GET_HOST_INFO, + RPC_QUIT, RPC_ACCT_MGR_INFO, - RPC_READ_GLOBAL_PREFS_OVERRIDE, - RPC_READ_CC_CONFIG, + RPC_GET_STATISTICS, RPC_NETWORK_AVAILABLE, RPC_GET_PROJECT_INIT_STATUS, - RPC_INIT, - RPC_GET_GLOBAL_PREFS_WORKING_STRUCT, - RPC_GET_GLOBAL_PREFS_OVERRIDE_STRUCT, - RPC_SET_GLOBAL_PREFS_OVERRIDE_STRUCT, - RPC_CREATE_ACCOUNT, - RPC_CREATE_ACCOUNT_POLL, + RPC_GET_PROJECT_CONFIG, + RPC_GET_PROJECT_CONFIG_POLL, RPC_LOOKUP_ACCOUNT, RPC_LOOKUP_ACCOUNT_POLL, + RPC_CREATE_ACCOUNT, + RPC_CREATE_ACCOUNT_POLL, RPC_PROJECT_ATTACH, RPC_PROJECT_ATTACH_FROM_FILE, RPC_PROJECT_ATTACH_POLL, - RPC_GET_ALL_PROJECTS_LIST + RPC_ACCT_MGR_RPC, + RPC_ACCT_MGR_RPC_POLL, + RPC_GET_NEWER_VERSION, + RPC_READ_GLOBAL_PREFS_OVERRIDE, + RPC_READ_CC_CONFIG, + RPC_GET_CC_STATUS, + RPC_GET_GLOBAL_PREFS_FILE, + RPC_GET_GLOBAL_PREFS_WORKING, + RPC_GET_GLOBAL_PREFS_WORKING_STRUCT, + RPC_GET_GLOBAL_PREFS_OVERRIDE, + RPC_SET_GLOBAL_PREFS_OVERRIDE, + RPC_GET_GLOBAL_PREFS_OVERRIDE_STRUCT, + RPC_SET_GLOBAL_PREFS_OVERRIDE_STRUCT, + RPC_SET_DEBTS, + NUM_RPC_SELECTORS }; struct ASYNC_RPC_REQUEST { RPC_SELECTOR which_rpc; - void *inBuf; + void *arg1; void *exchangeBuf; - void *outBuf; + void *arg2; + void *arg3; + void *arg4; wxEvent *event; wxEvtHandler *eventHandler; wxDateTime *completionTime; @@ -99,8 +108,141 @@ struct ASYNC_RPC_REQUEST { ASYNC_RPC_REQUEST(); ~ASYNC_RPC_REQUEST(); - void clear(); - bool isSameAs(ASYNC_RPC_REQUEST& otherRequest); + void clear(); + bool isSameAs(ASYNC_RPC_REQUEST& otherRequest); +}; + + +class AsyncRPC +{ +public: + AsyncRPC(CMainDocument *pDoc); + ~AsyncRPC(); + + int RPC_Wait(RPC_SELECTOR which_rpc, void* arg1 = NULL, void* arg2 = NULL, void* arg3 = NULL, void* arg4 = NULL); + + // Manager must do all RPC data transfers through AsyncRPC calls, so + // this class must have methods corresponding to all RPC_CLIENT data + // transfer operations, but NOT init(), init_async(), close(), etc. + int authorize(const char* passwd) + { return RPC_Wait(RPC_AUTHORIZE, (void*)passwd); } + int exchange_versions(VERSION_INFO& arg1) + { return RPC_Wait(RPC_EXCHANGE_VERSIONS, (void*)&arg1); } + int get_state(CC_STATE& arg1) + { return RPC_Wait(RPC_GET_STATE, (void*)&arg1); } + int get_results(RESULTS& arg1) + { return RPC_Wait(RPC_GET_RESULTS, (void*)&arg1); } + int get_file_transfers(FILE_TRANSFERS& arg1) + { return RPC_Wait(RPC_GET_FILE_TRANSFERS, (void*)&arg1); } + int get_simple_gui_info(SIMPLE_GUI_INFO& arg1) + { return RPC_Wait(RPC_GET_SIMPLE_GUI_INFO1, (void*)&arg1); } + int get_simple_gui_info(CC_STATE& ccbuf, RESULTS& rbuf) + { return RPC_Wait(RPC_GET_SIMPLE_GUI_INFO2, (void*)&ccbuf, (void*)&rbuf); } + int get_project_status(CC_STATE& arg1) + { return RPC_Wait(RPC_GET_PROJECT_STATUS1, (void*)&arg1); } + int get_project_status(PROJECTS& arg1) + { return RPC_Wait(RPC_GET_PROJECT_STATUS2, (void*)&arg1); } + int get_all_projects_list(ALL_PROJECTS_LIST& arg1) + { return RPC_Wait(RPC_GET_ALL_PROJECTS_LIST, (void*)&arg1); } + int get_disk_usage(DISK_USAGE& arg1) + { return RPC_Wait(RPC_GET_DISK_USAGE, (void*)&arg1); } + int show_graphics( + const char* project, const char* result_name, int graphics_mode, DISPLAY_INFO& di) + { return RPC_Wait(RPC_SHOW_GRAPHICS, (void*)&project, (void*)result_name, (void*)&graphics_mode, (void*)&di); } + int project_op(PROJECT& arg1, const char* op) + { return RPC_Wait(RPC_PROJECT_OP, (void*)&arg1, (void*)op); } + int set_run_mode(int mode, double duration) + { return RPC_Wait(RPC_SET_RUN_MODE, (void*)&mode, (void*)&duration); } + // if duration is zero, change is permanent. + // otherwise, after duration expires, + // restore last permanent mode + int set_network_mode(int mode, double duration) + { return RPC_Wait(RPC_SET_NETWORK_MODE, (void*)&mode, (void*)&duration); } + int get_screensaver_tasks(int& suspend_reason, RESULTS& rbuf) + { return RPC_Wait(RPC_GET_SCREENSAVER_TASKS, (void*)&suspend_reason, (void*)&rbuf); } + int run_benchmarks() + { return RPC_Wait(RPC_RUN_BENCHMARKS); } + int set_proxy_settings(GR_PROXY_INFO& arg1) + { return RPC_Wait(RPC_SET_PROXY_SETTINGS, (void*)&arg1); } + int get_proxy_settings(GR_PROXY_INFO& arg1) + { return RPC_Wait(RPC_GET_PROXY_SETTINGS, (void*)&arg1); } + int get_messages(int seqno, MESSAGES& arg1) + { return RPC_Wait(RPC_GET_MESSAGES, (void*)&arg1); } + int file_transfer_op(FILE_TRANSFER& arg1, const char* op) + { return RPC_Wait(RPC_FILE_TRANSFER_OP, (void*)&arg1, (void*)op); } + int result_op(RESULT& arg1, const char* op) + { return RPC_Wait(RPC_RESULT_OP, (void*)&arg1, (void*)op); } + int get_host_info(HOST_INFO& arg1) + { return RPC_Wait(RPC_GET_HOST_INFO, (void*)&arg1); } + int quit() + { return RPC_Wait(RPC_QUIT); } + int acct_mgr_info(ACCT_MGR_INFO& arg1) + { return RPC_Wait(RPC_ACCT_MGR_INFO, (void*)&arg1); } + int get_statistics(PROJECTS& arg1) + { return RPC_Wait(RPC_GET_STATISTICS, (void*)&arg1); } + int network_available() + { return RPC_Wait(RPC_NETWORK_AVAILABLE); } + int get_project_init_status(PROJECT_INIT_STATUS& pis) + { return RPC_Wait(RPC_GET_PROJECT_INIT_STATUS, (void*)&pis); } + + // the following are asynch operations. + // Make the first call to start the op, + // call the second one periodically until it returns zero. + // TODO: do project update + // + int get_project_config(std::string url) + { return RPC_Wait(RPC_GET_PROJECT_CONFIG, (void*)&url); } + int get_project_config_poll(PROJECT_CONFIG& arg1) + { return RPC_Wait(RPC_GET_PROJECT_CONFIG_POLL, (void*)&arg1); } + int lookup_account(ACCOUNT_IN& arg1) + { return RPC_Wait(RPC_LOOKUP_ACCOUNT, (void*)&arg1); } + int lookup_account_poll(ACCOUNT_OUT& arg1) + { return RPC_Wait(RPC_LOOKUP_ACCOUNT_POLL, (void*)&arg1); } + int create_account(ACCOUNT_IN& arg1) + { return RPC_Wait(RPC_CREATE_ACCOUNT, (void*)&arg1); } + int create_account_poll(ACCOUNT_OUT& arg1) + { return RPC_Wait(RPC_CREATE_ACCOUNT_POLL, (void*)&arg1); } + int project_attach( + const char* url, const char* auth, const char* project_name + ) { return RPC_Wait(RPC_PROJECT_ATTACH, (void*)url, (void*)auth, (void*)project_name); } + int project_attach_from_file() + { return RPC_Wait(RPC_PROJECT_ATTACH_FROM_FILE); } + int project_attach_poll(PROJECT_ATTACH_REPLY& arg1) + { return RPC_Wait(RPC_PROJECT_ATTACH_POLL, (void*)&arg1); } + int acct_mgr_rpc( + const char* url, const char* name, const char* passwd, + bool use_config_file=false + ) { return RPC_Wait(RPC_ACCT_MGR_RPC, (void*)url, (void*)name, (void*)passwd, (void*)&use_config_file); } + int acct_mgr_rpc_poll(ACCT_MGR_RPC_REPLY& arg1) + { return RPC_Wait(RPC_ACCT_MGR_RPC_POLL, (void*)&arg1); } + + int get_newer_version(std::string& arg1) + { return RPC_Wait(RPC_GET_NEWER_VERSION, (void*)&arg1); } + int read_global_prefs_override() + { return RPC_Wait(RPC_READ_GLOBAL_PREFS_OVERRIDE); } + int read_cc_config() + { return RPC_Wait(RPC_READ_CC_CONFIG); } + int get_cc_status(CC_STATUS& arg1) + { return RPC_Wait(RPC_GET_CC_STATUS, (void*)&arg1); } + int get_global_prefs_file(std::string& arg1) + { return RPC_Wait(RPC_GET_GLOBAL_PREFS_FILE, (void*)&arg1); } + int get_global_prefs_working(std::string& arg1) + { return RPC_Wait(RPC_GET_GLOBAL_PREFS_WORKING, (void*)&arg1); } + int get_global_prefs_working_struct(GLOBAL_PREFS& arg1, GLOBAL_PREFS_MASK& arg2) + { return RPC_Wait(RPC_GET_GLOBAL_PREFS_WORKING_STRUCT, (void*)&arg1, (void*)&arg2); } + int get_global_prefs_override(std::string& arg1) + { return RPC_Wait(RPC_GET_GLOBAL_PREFS_OVERRIDE, (void*)&arg1); } + int set_global_prefs_override(std::string& arg1) + { return RPC_Wait(RPC_SET_GLOBAL_PREFS_OVERRIDE, (void*)&arg1); } + int get_global_prefs_override_struct(GLOBAL_PREFS& arg1, GLOBAL_PREFS_MASK& arg2) + { return RPC_Wait(RPC_GET_GLOBAL_PREFS_OVERRIDE_STRUCT, (void*)&arg1, (void*)&arg2); } + int set_global_prefs_override_struct(GLOBAL_PREFS& arg1, GLOBAL_PREFS_MASK& arg2) + { return RPC_Wait(RPC_SET_GLOBAL_PREFS_OVERRIDE_STRUCT, (void*)&arg1, (void*)&arg2); } + int set_debts(std::vector arg1) + { return RPC_Wait(RPC_SET_DEBTS, (void*)&arg1); } + +private: + CMainDocument *m_Doc; }; @@ -108,13 +250,12 @@ class RPCThread : public wxThread { public: RPCThread(CMainDocument *pDoc); - virtual void *Entry(); - virtual void OnExit(); + virtual void *Entry(); + virtual void OnExit(); private: - int ProcessRPCRequest(); - - CMainDocument *m_Doc; + int ProcessRPCRequest(); + CMainDocument *m_Doc; }; @@ -124,12 +265,12 @@ class AsyncRPCDlg : public wxDialog public: AsyncRPCDlg(); - void OnRPCDlgTimer(wxTimerEvent &event); + void OnRPCDlgTimer(wxTimerEvent &event); #if USE_RPC_DLG_TIMER ~AsyncRPCDlg(); private: - wxTimer* m_pDlgDelayTimer; + wxTimer* m_pDlgDelayTimer; DECLARE_EVENT_TABLE() #endif // USE_RPC_DLG_TIMER @@ -147,10 +288,10 @@ public: virtual wxEvent * Clone() const { return new CRPCFinishedEvent(*this); } - void SetInt(int i) { m_retval = i; } - int GetInt() const { return m_retval; } + void SetInt(int i) { m_retval = i; } + int GetInt() const { return m_retval; } private: - int m_retval; + int m_retval; }; BEGIN_DECLARE_EVENT_TYPES()