// This file is part of BOINC. // http://boinc.berkeley.edu // Copyright (C) 2012 University of California // // BOINC is free software; you can redistribute it and/or modify it // under the terms of the GNU Lesser General Public License // as published by the Free Software Foundation, // either version 3 of the License, or (at your option) any later version. // // BOINC is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. // See the GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with BOINC. If not, see . #ifndef _PROJECT_ #define _PROJECT_ #include "app_config.h" #include "client_types.h" struct PROJECT : PROJ_AM { char _project_dir[MAXPATHLEN]; char _project_dir_absolute[MAXPATHLEN]; // the following items come from the account file // They are a function only of the user and the project // char authenticator[256]; // user's authenticator on this project std::string project_prefs; // without the enclosing tags. // May include elements // This field is used only briefly: between handling a // scheduler RPC reply and writing the account file std::string project_specific_prefs; // without enclosing tags // Does not include elements std::string gui_urls; // GUI URLs, with enclosing tags double resource_share; // project's resource share relative to other projects. double resource_share_frac; // temp; fraction of RS of non-suspended, compute-intensive projects double disk_resource_share; // temp in get_disk_shares() double desired_disk_usage; // reported by project double ddu; // temp in get_disk_shares() double disk_quota; // temp in get_disk_shares() // the following are from the user's project prefs // bool no_rsc_pref[MAX_RSC]; // derived from GPU exclusions in cc_config.xml; // disable work fetch if all instances excluded // bool no_rsc_config[MAX_RSC]; // the following are from the project itself // (or derived from app version list if anonymous platform) // bool no_rsc_apps[MAX_RSC]; // the following are from the account manager, if any // bool no_rsc_ams[MAX_RSC]; // the following set dynamically // bool rsc_defer_sched[MAX_RSC]; // This project has a GPU job for which there's insuff. video RAM. // Don't fetch more jobs of this type; they might have same problem char host_venue[256]; // logically, this belongs in the client state file // rather than the account file. // But we need it in the latter in order to parse prefs. bool using_venue_specific_prefs; // the following items come from client_state.xml // They may depend on the host as well as user and project // NOTE: if you add anything, add it to copy_state_fields() also!!! // std::vector scheduler_urls; // where to find scheduling servers char symstore[256]; // URL of symbol server (Windows) char user_name[256]; char team_name[256]; char email_hash[MD5_LEN]; char cross_project_id[MD5_LEN]; double cpid_time; double user_total_credit; double user_expavg_credit; double user_create_time; int userid; int teamid; int hostid; double host_total_credit; double host_expavg_credit; double host_create_time; double ams_resource_share; // resource share according to AMS; overrides project // -1 means not specified by AMS // stuff related to scheduler RPCs and master fetch // int rpc_seqno; int nrpc_failures; // # of consecutive times we've failed to contact all scheduling servers int master_fetch_failures; double min_rpc_time; // earliest time to contact any server of this project (or zero) void set_min_rpc_time(double future_time, const char* reason); double next_rpc_time; // if nonzero, specifies a time when another scheduler RPC // should be done (as requested by server). // An RPC could be done sooner than this. bool waiting_until_min_rpc_time(); // returns true if min_rpc_time > now bool master_url_fetch_pending; // need to fetch and parse the master URL int sched_rpc_pending; // we need to do a scheduler RPC, for various possible reasons: // user request, propagate host CPID, time-based, etc. // Reasons are enumerated in lib/common_defs.h bool possibly_backed_off; // we need to call request_work_fetch() when a project // transitions from being backed off to not. // This (slightly misnamed) keeps track of whether this // may still need to be done for given project bool trickle_up_pending; // have trickle up to send double last_rpc_time; // when last RPC finished // not maintained across client sessions // used by Manager (simple view) // Other stuff bool anonymous_platform; // app_versions.xml file found in project dir; // use those apps rather then getting from server bool non_cpu_intensive; // All this project's apps are non-CPU-intensive. // Apps can also be individually marked as NCI bool verify_files_on_app_start; // Check app version and input files on app startup, // to make sure they haven't been tampered with. // This provides only the illusion of security. bool use_symlinks; double disk_usage; // computed by get_disk_usages() double disk_share; // computed by get_disk_shares(); // items send in scheduler replies, requesting that // various things be sent in the next request // int send_time_stats_log; // if nonzero, send time stats log from that point on int send_job_log; // if nonzero, send this project's job log from that point on bool send_full_workload; bool dont_use_dcf; bool suspended_via_gui; bool dont_request_more_work; // Return work, but don't request more // Used for a clean exit to a project, // or if a user wants to pause doing work for the project bool attached_via_acct_mgr; bool detach_when_done; // when no results for this project, detach it. bool ended; // project has ended; advise user to detach char code_sign_key[MAX_KEY_LEN]; std::vector user_files; std::vector project_files; // files not specific to apps or work - e.g. icons int parse_preferences_for_user_files(); void write_project_files(MIOFILE&); void link_project_files(); void create_project_file_symlinks(); void delete_project_file_symlinks(); int write_symlink_for_project_file(FILE_INFO*); double project_files_downloaded_time; // when last project file download finished void update_project_files_downloaded_time(); // called when a project file download finishes. // If it's the last one, set project_files_downloaded_time to now double duration_correction_factor; // Multiply by this when estimating the CPU time of a result // (based on FLOPs estimated and benchmarks). // This is dynamically updated in a way that maintains an upper bound. // it goes down slowly but if a new estimate X is larger, // the factor is set to X. // // Deprecated - current server logic handles this, // and this should go to 1. // But we need to keep it around for older projects void update_duration_correction_factor(ACTIVE_TASK*); // fields used by CPU scheduler and work fetch // everything from here on applies only to CPU intensive projects bool can_request_work(); // not suspended and not deferred and not no more work bool runnable(int rsc_type); // has a runnable result using the given resource type bool downloading(); // has a result in downloading state bool potentially_runnable(); // runnable or contactable or downloading bool nearly_runnable(); // runnable or downloading bool overworked(); // the project has used too much CPU time recently bool some_download_stalled(); // a download is backed off bool some_result_suspended(); double last_upload_start; // the last time an upload was started. // Used for "work fetch deferral" mechanism: // don't request work from a project if an upload started // in last X minutes and is still active bool uploading(); bool has_results(); struct RESULT *next_runnable_result; // the next result to run for this project int nuploading_results; // number of results in UPLOADING state // Don't start new results if these exceeds 2*ncpus. bool too_many_uploading_results; // scheduling (work fetch and job scheduling) // double sched_priority; void compute_sched_priority(); // stuff for RR sim // double rr_sim_cpu_share; bool rr_sim_active; bool operator<(const PROJECT& p) { return sched_priority > p.sched_priority; } // stuff related to work fetch // RSC_PROJECT_WORK_FETCH rsc_pwf[MAX_RSC]; PROJECT_WORK_FETCH pwf; inline void reset() { for (int i=0; i trickle_up_ops; // app config stuff // APP_CONFIGS app_configs; PROJECT(); ~PROJECT(){} void init(); void copy_state_fields(PROJECT&); int write_account_file(); int parse_account(FILE*); int parse_account_file_venue(); int parse_account_file(); int parse_state(XML_PARSER&); int write_state(MIOFILE&, bool gui_rpc=false); const char* project_dir(); const char* project_dir_absolute(); // statistic of the last x days std::vector statistics; int parse_statistics(MIOFILE&); int parse_statistics(FILE*); int write_statistics(MIOFILE&); int write_statistics_file(); void trim_statistics(); void suspend(); void resume(); void abort_not_started(); // abort unstarted jobs // clear AMS-related fields inline void detach_ams() { attached_via_acct_mgr = false; ams_resource_share = -1; for (int i=0; i