~ubuntu-branches/ubuntu/precise/boinc/precise

#ifdef _MSC_VER

#define snprintf _snprintf

#endif

// Do periodic checks on running apps:

// - get latest CPU time and % done info

// - check if any has exited, and clean up

// - see if any has exceeded its CPU or disk space limits, and abort it

//

bool ACTIVE_TASK_SET::poll() {

    bool action;

    unsigned int i;

    static double last_time = 0;

    if (gstate.now - last_time < TASK_POLL_PERIOD) return false;

    last_time = gstate.now;

 

    action = check_app_exited();

    send_heartbeats();

    send_trickle_downs();

    graphics_poll();

    process_control_poll();

    action |= check_rsc_limits_exceeded();

    get_msgs();

    for (i=0; i<active_tasks.size(); i++) {

        ACTIVE_TASK* atp = active_tasks[i];

        if (atp->task_state() == PROCESS_ABORT_PENDING) {

            if (gstate.now > atp->abort_time + ABORT_TIMEOUT) {

                atp->kill_task(false);

            }

        }

        if (atp->task_state() == PROCESS_QUIT_PENDING) {

            if (gstate.now > atp->quit_time + QUIT_TIMEOUT) {

                atp->kill_task(true);

            }

        }

    }

 

    if (action) {

        gstate.set_client_state_dirty("ACTIVE_TASK_SET::poll");

    }

 

    return action;

}

 

#if 0

// deprecated; TerminateProcessById() doesn't work if

// the process is running as a different user

//

#endif

    TerminateProcess(process_handle, 1);

        char buf[256];

        sprintf(buf, "restarting %s", result->name);

                gstate.request_schedule_cpus(buf);

    if (GetExitCodeProcess(process_handle, &exit_code)) {

static void clear_backoffs(ACTIVE_TASK* atp) {

    int rt = atp->result->avp->rsc_type();

    if (rt == RSC_TYPE_CPU) return;

    for (unsigned int i=0; i<gstate.results.size(); i++) {

        RESULT* rp = gstate.results[i];

        if (rp->avp->rsc_type() == rt) {

            rp->schedule_backoff = 0;

        }

    }

}

 

            "[task] Process for %s exited",

    result->final_elapsed_time = elapsed_time;

            double x;

            if (temporary_exit_file_present(x)) {

                if (log_flags.task_debug) {

                    msg_printf(result->project, MSG_INFO,

                        "[task] task called temporary_exit(%f)", x

                    );

                }

                set_task_state(PROCESS_UNINITIALIZED, "temporary exit");

                will_restart = true;

                result->schedule_backoff = gstate.now + x;

                break;

            }

                    "[task] Process for %s exited",

                    "[task] exit code %d (0x%x): %s",

            double x;

            if (temporary_exit_file_present(x)) {

                if (log_flags.task_debug) {

                    msg_printf(result->project, MSG_INFO,

                        "[task] task called temporary_exit(%f)", x

                    );

                }

                set_task_state(PROCESS_UNINITIALIZED, "temporary exit");

                will_restart = true;

                result->schedule_backoff = gstate.now + x;

            } else {

                if (log_flags.task_debug) {

                    msg_printf(result->project, MSG_INFO,

                        "[task] process exited with status %d\n",

                        result->exit_status

                    );

                }

                    "[task] process got signal %d", signal

    if (config.exit_after_finish) {

        client_clean_out_dir(slot_dir, "handle_exited_app()");

        clear_backoffs(this);   // clear scheduling backoffs of jobs waiting for GPU

bool ACTIVE_TASK::temporary_exit_file_present(double& x) {

    char path[256];

    sprintf(path, "%s/%s", slot_dir, TEMPORARY_EXIT_FILE);

    FILE* f = fopen(path, "r");

    if (!f) return false;

    int y;

    int n = fscanf(f, "%d", &y);

    fclose(f);

    if (n != 1 || y < 0 || y > 86400) {

        x = 300;

    } else {

        x = y;

    }

    return true;

}

 

        char buf[1024];

                snprintf(buf, sizeof(buf), "<heartbeat/>"

                        "<wss>%e</wss>"

                        "<max_wss>%e</max_wss>",

                msg_printf(atp->result->project, MSG_INFO,

        if (GetExitCodeProcess(atp->process_handle, &exit_code)) {

                msg_printf(atp->result->project, MSG_INFO,

                    "[task] task %s GetExitCodeProcess() failed - %s GLE %d (0x%x)",

    if ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {

                msg_printf(NULL, MSG_INTERNAL_ERROR,

                    "Process %d not found\n", pid

                );

        msg_printf(this->wup->project, MSG_INTERNAL_ERROR,

                if (!atp->result->project->non_cpu_intensive && (atp->elapsed_time > atp->max_elapsed_time)) {

                                "Aborting task %s: exceeded elapsed time limit %.2f (%.2fG/%.2fG)",

                                atp->result->name, atp->max_elapsed_time,

                atp->result->wup->rsc_fpops_bound/1e9,

                atp->result->avp->flops/1e9

                        atp->abort_task(ERR_RSC_LIMIT_EXCEEDED, "Maximum elapsed time exceeded");

    if (read_file_string(path, stderr_file, max_len, !config.stderr_head)) {

        return false;

    }