client/client_types.h (r16139/r16130)

Go to the documentation of this file.

// This file is part of BOINC.
// http://boinc.berkeley.edu
// Copyright (C) 2008 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 <http://www.gnu.org/licenses/>.

// If you change anything, make sure you also change:
// client_types.C         (to write and parse it)
// client_state.C  (to cross-link objects)
//

#ifndef _CLIENT_TYPES_
#define _CLIENT_TYPES_

#include "cpp.h"

#if !defined(_WIN32) || defined(__CYGWIN32__)
#include <stdio.h>
#include <sys/time.h>
#endif

#include "md5_file.h"
#include "cert_sig.h"
#include "hostinfo.h"
#include "coproc.h"
#include "miofile.h"

#define P_LOW 1
#define P_MEDIUM 3
#define P_HIGH 5

#define MAX_FILE_INFO_LEN   4096
#define MAX_SIGNATURE_LEN   4096
#define MAX_KEY_LEN         4096

// If the status is neither of these two,
// it will be an error code defined in error_numbers.h,
// indicating an unrecoverable error in the upload or download of the file,
// or that the file was too big and was deleted
//
#define FILE_NOT_PRESENT    0
#define FILE_PRESENT        1

class FILE_INFO {
public:
    char name[256];
    char md5_cksum[33];
    double max_nbytes;
    double nbytes;
    double upload_offset;
    bool generated_locally; // file is produced by app
    int status;
    bool executable;        // change file protections to make executable
    bool uploaded;          // file has been uploaded
    bool upload_when_present;
    bool sticky;            // don't delete unless instructed to do so
    bool report_on_rpc;     // include this in each scheduler request
    bool marked_for_delete;     // server requested delete;
    bool signature_required;    // true iff associated with app version
    bool is_user_file;
    bool is_project_file;
    bool is_auto_update_file;
    bool gzip_when_done;
    class PERS_FILE_XFER* pers_file_xfer;
    struct RESULT* result;
    class PROJECT* project;
    int ref_cnt;
    std::vector<std::string> urls;
    int start_url;
    int current_url;
    char signed_xml[MAX_FILE_INFO_LEN];
    char xml_signature[MAX_SIGNATURE_LEN];
    char file_signature[MAX_SIGNATURE_LEN];
    std::string error_msg;
    CERT_SIGS* cert_sigs;

    FILE_INFO();
    ~FILE_INFO();
    void reset();
    int set_permissions();
    int parse(MIOFILE&, bool from_server);
    int write(MIOFILE&, bool to_server);
    int write_gui(MIOFILE&);
    int delete_file();
    const char* get_init_url(bool);
    const char* get_next_url(bool);
    const char* get_current_url(bool);
    bool is_correct_url_type(bool, std::string&);
    bool had_failure(int& failnum);
    void failure_message(std::string&);
    int merge_info(FILE_INFO&);
    int verify_file(bool, bool);
    bool verify_file_certs();
    int gzip();
};



struct FILE_REF {
    char file_name[256];
    char open_name[256];
    bool main_program;
    FILE_INFO* file_info;
    bool copy_file;
    bool optional;
    int parse(MIOFILE&);
    int write(MIOFILE&);
};


struct DAILY_STATS {
    double user_total_credit;
    double user_expavg_credit;
    double host_total_credit;
    double host_expavg_credit;
    double day;

    void clear();
    DAILY_STATS() {clear();}
    int parse(FILE*);
};
bool operator < (const DAILY_STATS&, const DAILY_STATS&);

struct RR_SIM_PROJECT_STATUS {
    std::vector<RESULT*>active;
    std::vector<RESULT*>pending;
    int deadlines_missed;
    double proc_rate;
    double cpu_shortfall;

    inline void clear() {
        active.clear();
        pending.clear();
        deadlines_missed = 0;
        proc_rate = 0;
        cpu_shortfall = 0;
    }
    inline void activate(RESULT* rp) {
        active.push_back(rp);
    }
    inline void add_pending(RESULT* rp) {
        pending.push_back(rp);
    }
    inline bool none_active() {
        return !active.size();
    }
    inline bool can_run(RESULT*, int ncpus) {
        return (int)active.size() < ncpus;
    }
    inline void remove_active(RESULT* r) {
        std::vector<RESULT*>::iterator it = active.begin();
        while (it != active.end()) {
            if (*it == r) {
                it = active.erase(it);
            } else {
                it++;
            }
        }
    }
    inline RESULT* get_pending() {
        if (!pending.size()) return NULL;
        RESULT* rp = pending[0];
        pending.erase(pending.begin());
        return rp;
    }
    inline int cpus_used() {
        return (int) active.size();
    }
};

class PROJECT {
public:
    // the following items come from the account file
    // They are a function only of the user and the project
    //
    char master_url[256];
    char authenticator[256];
    std::string project_prefs;
    std::string project_specific_prefs;
    std::string gui_urls;
    double resource_share;
    char host_venue[256];
    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<std::string> scheduler_urls;
    char project_name[256];
    char symstore[256];
    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 hostid;
    double host_total_credit;
    double host_expavg_credit;
    double host_create_time;
    double ams_resource_share;

    // stuff related to scheduler RPCs and master fetch
    //
    int rpc_seqno;
    int nrpc_failures;
    int master_fetch_failures;
    double min_rpc_time;
    void set_min_rpc_time(double future_time, const char* reason);
    bool waiting_until_min_rpc_time();
    bool master_url_fetch_pending;
    int sched_rpc_pending;
    double next_rpc_time;
    bool possibly_backed_off;
    bool trickle_up_pending;
    double last_rpc_time;

    // Other stuff

    bool anonymous_platform;
    bool non_cpu_intensive;
    bool verify_files_on_app_start;
    bool use_symlinks;

    // items send in scheduler replies, requesting that
    // various things be sent in the next request
    //
    bool send_file_list;
    int send_time_stats_log;
    int send_job_log;

    bool suspended_via_gui;
    bool dont_request_more_work; 
    bool attached_via_acct_mgr;
    bool detach_when_done;
    bool ended;
    char code_sign_key[MAX_KEY_LEN];
    std::vector<FILE_REF> user_files;
    std::vector<FILE_REF> project_files;
    int parse_preferences_for_user_files();
    int parse_project_files(MIOFILE&, bool delete_existing_symlinks);
    void write_project_files(MIOFILE&);
    void link_project_files(bool recreate_symlink_files);
    int write_symlink_for_project_file(FILE_INFO*);
    double project_files_downloaded_time;
    void update_project_files_downloaded_time();

    double duration_correction_factor;
    void update_duration_correction_factor(RESULT*);
    
    // fields used by CPU scheduler and work fetch
    // everything from here on applies only to CPU intensive projects

    bool contactable();
    bool runnable();
    bool downloading();
    bool potentially_runnable();
    bool nearly_runnable();
    bool overworked();
    bool some_download_stalled();
    bool some_result_suspended();

    RR_SIM_PROJECT_STATUS rr_sim_status;
        // temps used in CLIENT_STATE::rr_simulation();
    void set_rrsim_proc_rate(double rrs);

    int deadlines_missed;

    // "debt" is how much CPU time we owe this project relative to others

    double short_term_debt;
    double long_term_debt;

    double anticipated_debt;
    double wall_cpu_time_this_debt_interval;
    struct RESULT *next_runnable_result;
    int nuploading_results;

    double work_request;
    int work_request_urgency;

    int nresults_returned;
    const char* get_scheduler_url(int index, double r);
    bool checked;

    // vars related to file-transfer backoff
    // file_xfer_failures_up: count of consecutive upload failures
    // next_file_xfer_up: when to start trying uploads again
    //
    // if file_xfer_failures_up exceeds FILE_XFER_FAILURE_LIMIT,
    // we switch from a per-file to a project-wide backoff policy
    // (separately for the up/down directions)
    //
    // NOTE: all this refers to transient failures, not permanent.
    // Also, none of this is used right now (commented out)
    //
#define FILE_XFER_FAILURE_LIMIT 3
    int file_xfer_failures_up;
    int file_xfer_failures_down;
    double next_file_xfer_up;
    double next_file_xfer_down;

    double next_file_xfer_time(const bool);
    void file_xfer_failed(const bool);
    void file_xfer_succeeded(const bool);

    PROJECT();
    ~PROJECT(){}
    void init();
    void copy_state_fields(PROJECT&);
    char *get_project_name();
    int write_account_file();
    int parse_account(FILE*);
    int parse_account_file_venue();
    int parse_account_file();
    int parse_state(MIOFILE&);
    int write_state(MIOFILE&, bool gui_rpc=false);

    // statistic of the last x days
    std::vector<DAILY_STATS> statistics;
    int parse_statistics(MIOFILE&);
    int parse_statistics(FILE*);
    int write_statistics(MIOFILE&, bool gui_rpc=false);
    int write_statistics_file();
};

struct APP {
    char name[256];
    char user_friendly_name[256];
    PROJECT* project;

    int parse(MIOFILE&);
    int write(MIOFILE&);
};

struct APP_VERSION {
    char app_name[256];
    int version_num;
    char platform[256];
    char plan_class[64];
    char api_version[16];
    double avg_ncpus;
    double max_ncpus;
    double flops;
    char cmdline[256];
    COPROCS coprocs;

    APP* app;
    PROJECT* project;
    std::vector<FILE_REF> app_files;
    int ref_cnt;
    char graphics_exec_path[512];

    APP_VERSION(){}
    ~APP_VERSION(){}
    int parse(MIOFILE&);
    int write(MIOFILE&);
    bool had_download_failure(int& failnum);
    void get_file_errors(std::string&);
    void clear_errors();
    int api_major_version();
};

struct WORKUNIT {
    char name[256];
    char app_name[256];
    int version_num;
    std::string command_line;
    std::vector<FILE_REF> input_files;
    PROJECT* project;
    APP* app;
    int ref_cnt;
    double rsc_fpops_est;
    double rsc_fpops_bound;
    double rsc_memory_bound;
    double rsc_disk_bound;

    WORKUNIT(){}
    ~WORKUNIT(){}
    int parse(MIOFILE&);
    int write(MIOFILE&);
    bool had_download_failure(int& failnum);
    void get_file_errors(std::string&);
    void clear_errors();
};

struct RESULT {
    char name[256];
    char wu_name[256];
    double report_deadline;
    int version_num;        // identifies the app used
    char plan_class[64];
    char platform[256];
    APP_VERSION* avp;
    std::vector<FILE_REF> output_files;
    bool ready_to_report;
    double completed_time;
    bool got_server_ack;
    double final_cpu_time;

    // the following are nonzero if reported by app
    double fpops_per_cpu_sec;
    double fpops_cumulative;
    double intops_per_cpu_sec;
    double intops_cumulative;

    int _state;
    inline int state() { return _state; }
    void set_state(int, const char*);
    int exit_status;
    std::string stderr_out;
    bool suspended_via_gui;

    APP* app;
    WORKUNIT* wup;
    PROJECT* project;

    RESULT(){}
    ~RESULT(){}
    void clear();
    int parse_server(MIOFILE&);
    int parse_state(MIOFILE&);
    int parse_name(FILE*, const char* end_tag);
    int write(MIOFILE&, bool to_server);
    int write_gui(MIOFILE&);
    bool is_upload_done();    // files uploaded?
    void clear_uploaded_flags();
    FILE_REF* lookup_file(FILE_INFO*);
    FILE_INFO* lookup_file_logical(const char*);

    void abort_inactive(int);
    void append_log_record();

    // stuff related to CPU scheduling

    double estimated_cpu_time(bool for_work_fetch);
    double estimated_cpu_time_uncorrected();
    double estimated_cpu_time_remaining(bool for_work_fetch);
    bool computing_done();
    bool runnable();
    bool nearly_runnable();
    bool downloading();
    bool some_download_stalled();
    bool uses_coprocs() {
        return (avp->coprocs.coprocs.size() > 0);
    }

    // temporaries used in CLIENT_STATE::rr_simulation():
    double rrsim_cpu_left;
    double rrsim_finish_delay;
    bool already_selected;
    double computation_deadline();
    bool rr_sim_misses_deadline;
    bool last_rr_sim_missed_deadline;

    bool edf_scheduled;
};


class MODE {
private:
    int perm_mode;
    int temp_mode;
    double temp_timeout;
public:
    MODE();
    void set(int mode, double duration);
    int get_perm();
    int get_current();
    double delay();
};


class PLATFORM {
public:
    std::string name;
};

#endif

---