job.hpp

Go to the documentation of this file.

#ifndef SAGA_PACKAGES_JOB_JOB_HPP
#define SAGA_PACKAGES_JOB_JOB_HPP

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 1, output: "preprocessed/job.hpp")
#endif
//  Copyright (c) 2005-2009 Hartmut Kaiser
//  Copyright (c) 2007 Ole Weidner (oweidner@cct.lsu.edu)
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif

#include <string>
#include <vector>
#include <iosfwd>

// include dependent spec sections
#include <saga/saga/util.hpp>
#include <saga/saga/base.hpp>
#include <saga/saga/types.hpp>
#include <saga/saga/session.hpp>
#include <saga/saga/call.hpp>

#include <saga/saga/packages/job/config.hpp>
#include <saga/saga/packages/job/job_description.hpp>
#include <saga/saga/packages/job/istream.hpp>
#include <saga/saga/packages/job/ostream.hpp>

#include <saga/saga/detail/attribute.hpp>
#include <saga/saga/detail/permissions.hpp>

// suppress warnings about dependent classes not being exported from the dll
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable: 4251 4231 4275 4660)
#endif

#ifdef SAGA_DEBUG
#include <saga/saga/packages/job/preprocessed/job.hpp>
#else

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 1, output: "preprocessed/job.hpp")
#endif

namespace saga
{
    namespace job {

    namespace attributes
    {
        //  read only attributes
        char const* const jobid = "JobID";
        char const* const execution_hosts = "ExecutionHosts";
        char const* const created = "Created";
        char const* const started = "Started";
        char const* const finished = "Finished";
        char const* const working_directory = "WorkingDirectory";
        char const* const exitcode = "ExitCode";
        char const* const termsig = "Termsig";
        char const* const job_service = "JobService";
    }

    namespace metrics
    {
        char const* const state = saga::metrics::task_state;
        char const* const state_detail = "job.state_detail";
        char const* const signal = "job.signal";
        char const* const cpu_time = "job.cpu_time";
        char const* const memory_use = "job.memory_use";
        char const* const vmemory_use = "job.vmemory_use";
        char const* const performance = "job.performance";
    }

    namespace attributes
    {
        // textual representations of job states
        char const* const job_state_unknown   = saga::attributes::task_state_unknown;
        char const* const job_state_new       = saga::attributes::task_state_new;
        char const* const job_state_running   = saga::attributes::task_state_running;
        char const* const job_state_done      = saga::attributes::task_state_done;
        char const* const job_state_canceled  = saga::attributes::task_state_canceled;
        char const* const job_state_failed    = saga::attributes::task_state_failed;
        char const* const job_state_suspended = "Suspended";
    }

    enum state
    {
        Unknown   =  saga::task_base::Unknown,   // -1

        New       =  saga::task_base::New,       //  1

        Running   =  saga::task_base::Running,   //  2

        Done      =  saga::task_base::Done,      //  3

        Canceled  =  saga::task_base::Canceled,  //  4

        Failed    =  saga::task_base::Failed,    //  5

        Suspended =  6
    };

    namespace detail
    {
        SAGA_JOB_PACKAGE_EXPORT std::string get_state_name(state s);
    }

    class SAGA_JOB_PACKAGE_EXPORT job
        : public saga::task,
          public saga::detail::attribute<job>,
          public saga::detail::permissions<job>
    {
    private:
        friend struct saga::detail::attribute<job>;  // needs to access get_impl()
        friend struct saga::detail::permissions<job>;

        // job inspection
        SAGA_CALL_PRIV_0(get_job_id)
        SAGA_CALL_PRIV_0(get_state)
        SAGA_CALL_PRIV_0(get_description)

        // job task interface
        SAGA_CALL_PRIV_0(run)
        SAGA_CALL_PRIV_1(cancel, double)
        SAGA_CALL_PRIV_1(wait, double)

        // The following functions are a bit special because they do not provide
        // the usual plain sync interface function returning the result. We have
        // the task based variants available only.
        SAGA_CALL_PRIV_0(get_stdin)
        SAGA_CALL_PRIV_0(get_stdout)
        SAGA_CALL_PRIV_0(get_stderr)

        // job management
        SAGA_CALL_PRIV_0(suspend)
        SAGA_CALL_PRIV_0(resume)
        SAGA_CALL_PRIV_0(checkpoint)
        SAGA_CALL_PRIV_1(migrate, description)
        SAGA_CALL_PRIV_1(signal, int)

    protected:

        typedef saga::detail::attribute<job> attribute_base;

        TR1::shared_ptr <saga::impl::job> get_impl_sp (void) const;
        saga::impl::job * get_impl (void) const;
        bool is_impl_valid() const;

        explicit job (saga::impl::job *);

    public:
        job();

        explicit job (saga::object const& o);

        ~job();

        job &operator= (saga::object const& o);

        std::string get_job_id()
        {
            saga::task t = get_job_idpriv(saga::task_base::Sync());
            return t.get_result<std::string>();
        }
        SAGA_CALL_PUB_0_DEF_0(get_job_id)

        
        void run()
        {
            saga::task t = runpriv(saga::task_base::Sync());
            t.get_result ();
        }
        SAGA_CALL_PUB_0_DEF_0(run)

        
        bool wait(double timeout = -1.0)
        {
            saga::task t = waitpriv(timeout, saga::task_base::Sync());
            return t.get_result<bool>();
        }
        SAGA_CALL_PUB_1_DEF_1(wait, double, -1.0)

        
        void cancel(double timeout = 0.0)
        {
            saga::task t = cancelpriv(timeout, saga::task_base::Sync());
            t.get_result ();
        }
        SAGA_CALL_PUB_1_DEF_1(cancel, double, 0.0)

        
        saga::job::state get_state()
        {
            saga::task t = get_statepriv(saga::task_base::Sync());
            return t.get_result<saga::job::state>();
        }
        SAGA_CALL_PUB_0_DEF_0(get_state)

        
        saga::job::description get_description()
        {
            saga::task t = get_descriptionpriv(saga::task_base::Sync());
            return t.get_result<saga::job::description>();
        }
        SAGA_CALL_PUB_0_DEF_0(get_description)

        
        saga::job::ostream get_stdin()
        {
            saga::task t = get_stdinpriv(saga::task_base::Sync());
            return t.get_result<saga::job::ostream>();
        }
        SAGA_CALL_PUB_0_DEF_0(get_stdin)

        
        saga::job::istream get_stdout()
        {
            saga::task t = get_stdoutpriv(saga::task_base::Sync());
            return t.get_result<saga::job::istream>();
        }
        SAGA_CALL_PUB_0_DEF_0(get_stdout)

        
        saga::job::istream get_stderr()
        {
            saga::task t = get_stderrpriv(saga::task_base::Sync());
            return t.get_result<saga::job::istream>();
        }
        SAGA_CALL_PUB_0_DEF_0(get_stderr)

        
        void suspend()
        {
            saga::task t = suspendpriv(saga::task_base::Sync());
            t.get_result ();
        }
        SAGA_CALL_PUB_0_DEF_0(suspend)

        
        void resume()
        {
            saga::task t = resumepriv(saga::task_base::Sync());
            t.get_result ();
        }
        SAGA_CALL_PUB_0_DEF_0(resume)

        
        void checkpoint()
        {
            saga::task t = checkpointpriv(saga::task_base::Sync());
            t.get_result ();
        }
        SAGA_CALL_PUB_0_DEF_0(checkpoint)

        
        void migrate(description job_desc)
        {
            saga::task t = migratepriv(job_desc, saga::task_base::Sync());
            t.get_result ();
        }
        SAGA_CALL_PUB_1_DEF_0(migrate, description)

        
        void (signal)(int signal)
        {
            saga::task t = signalpriv(signal, saga::task_base::Sync());
            t.get_result ();
        }
        SAGA_CALL_PUB_1_DEF_0(signal, int)
    };

    }   // namespace job

    namespace adaptors
    {
        saga::job::state SAGA_JOB_PACKAGE_EXPORT 
            job_state_value_to_enum(std::string const& val);
        std::string SAGA_JOB_PACKAGE_EXPORT 
            job_state_enum_to_value(int s);
    }
}   // namespace saga

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif

#endif // !defined(SAGA_DEBUG)

// re-enable warnings about dependent classes not being exported from the dll
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif

#endif // !defined(SAGA_PACKAGES_JOB_JOB_HPP)