X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/93ae3804979dbbefc774e5a70acc32a4407dd7e8..60037b3f9ba9d856ccebf7a2211b51b82f4a557a:/src/kernel/activity/IoImpl.cpp diff --git a/src/kernel/activity/IoImpl.cpp b/src/kernel/activity/IoImpl.cpp index 822ff10cea..8472157856 100644 --- a/src/kernel/activity/IoImpl.cpp +++ b/src/kernel/activity/IoImpl.cpp @@ -7,142 +7,165 @@ #include "simgrid/Exception.hpp" #include "simgrid/kernel/resource/Action.hpp" #include "simgrid/s4u/Host.hpp" +#include "src/kernel/resource/DiskImpl.hpp" #include "src/mc/mc_replay.hpp" #include "src/simix/smx_private.hpp" #include "src/surf/StorageImpl.hpp" +#include "src/surf/cpu_interface.hpp" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_io, simix, "Logging specific to SIMIX (io)"); -void simcall_HANDLER_io_wait(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* synchro) +void simcall_HANDLER_io_wait(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* synchro, double timeout) { XBT_DEBUG("Wait for execution of synchro %p, state %d", synchro, (int)synchro->state_); /* Associate this simcall to the synchro */ - synchro->simcalls_.push_back(simcall); - simcall->issuer->waiting_synchro = synchro; + synchro->register_simcall(simcall); - /* set surf's synchro */ if (MC_is_active() || MC_record_replay_is_active()) { - synchro->state_ = SIMIX_DONE; + int idx = SIMCALL_GET_MC_VALUE(*simcall); + if (idx == 0) { + synchro->state_ = simgrid::kernel::activity::State::DONE; + } else { + /* If we reached this point, the wait simcall must have a timeout */ + /* Otherwise it shouldn't be enabled and executed by the MC */ + if (timeout < 0.0) + THROW_IMPOSSIBLE; + synchro->state_ = simgrid::kernel::activity::State::TIMEOUT; + } synchro->finish(); - return; } /* If the synchro is already finished then perform the error handling */ - if (synchro->state_ != SIMIX_RUNNING) + if (synchro->state_ != simgrid::kernel::activity::State::RUNNING) + synchro->finish(); + else { + /* we need a sleep action (even when there is no timeout) to be notified of host failures */ + if (synchro->get_disk() != nullptr) + synchro->timeout_detector_ = synchro->get_disk()->get_host()->pimpl_cpu->sleep(timeout); + else + synchro->timeout_detector_ = + simgrid::s4u::Host::by_name(synchro->get_storage()->get_host())->pimpl_cpu->sleep(timeout); + synchro->timeout_detector_->set_activity(synchro); + } +} + +void simcall_HANDLER_io_test(smx_simcall_t simcall, simgrid::kernel::activity::IoImpl* synchro) +{ + bool res = (synchro->state_ != simgrid::kernel::activity::State::WAITING && + synchro->state_ != simgrid::kernel::activity::State::RUNNING); + if (res) { + synchro->simcalls_.push_back(simcall); synchro->finish(); + } else { + simcall->issuer_->simcall_answer(); + } + simcall_io_test__set__result(simcall, res); } namespace simgrid { namespace kernel { namespace activity { -IoImpl::~IoImpl() +IoImpl& IoImpl::set_type(s4u::Io::OpType type) { - if (surf_action_ != nullptr) - surf_action_->unref(); - XBT_DEBUG("Destroy io %p", this); + type_ = type; + return *this; } -IoImplPtr IoImpl::set_name(const std::string& name) +IoImpl& IoImpl::set_size(sg_size_t size) { - ActivityImpl::set_name(name); - return this; + size_ = size; + return *this; } -IoImplPtr IoImpl::set_type(s4u::Io::OpType type) +IoImpl& IoImpl::set_disk(resource::DiskImpl* disk) { - type_ = type; - return this; + disk_ = disk; + return *this; } -IoImplPtr IoImpl::set_size(sg_size_t size) -{ - size_ = size; - return this; -} - -IoImplPtr IoImpl::set_storage(resource::StorageImpl* storage) +IoImpl& IoImpl::set_storage(resource::StorageImpl* storage) { storage_ = storage; - return this; + return *this; } IoImpl* IoImpl::start() { - state_ = SIMIX_RUNNING; - surf_action_ = storage_->io_start(size_, type_); - surf_action_->set_data(this); + state_ = State::RUNNING; + if (storage_) + surf_action_ = storage_->io_start(size_, type_); + else + surf_action_ = disk_->io_start(size_, type_); + surf_action_->set_activity(this); XBT_DEBUG("Create IO synchro %p %s", this, get_cname()); - IoImpl::on_start(this); + IoImpl::on_start(*this); return this; } -void IoImpl::cancel() -{ - XBT_VERB("This exec %p is canceled", this); - if (surf_action_ != nullptr) - surf_action_->cancel(); - state_ = SIMIX_CANCELED; -} - -double IoImpl::get_remaining() -{ - return surf_action_ ? surf_action_->get_remains() : 0; -} - void IoImpl::post() { performed_ioops_ = surf_action_->get_cost(); - switch (surf_action_->get_state()) { - case resource::Action::State::FAILED: - state_ = SIMIX_FAILED; - break; - case resource::Action::State::FINISHED: - state_ = SIMIX_DONE; - break; - default: - THROW_IMPOSSIBLE; + if (surf_action_->get_state() == resource::Action::State::FAILED) { + if ((storage_ && not storage_->is_on()) || (disk_ && not disk_->is_on())) + state_ = State::FAILED; + else + state_ = State::CANCELED; + } else if (surf_action_->get_state() == resource::Action::State::FINISHED) { + state_ = State::DONE; + } else if (timeout_detector_ && timeout_detector_->get_state() == resource::Action::State::FINISHED) { + state_ = State::TIMEOUT; + } + + if (timeout_detector_) { + timeout_detector_->unref(); + timeout_detector_ = nullptr; } - on_completion(this); + on_completion(*this); + + /* Answer all simcalls associated with the synchro */ finish(); } void IoImpl::finish() { - for (smx_simcall_t const& simcall : simcalls_) { + while (not simcalls_.empty()) { + smx_simcall_t simcall = simcalls_.front(); + simcalls_.pop_front(); switch (state_) { - case SIMIX_DONE: + case State::DONE: /* do nothing, synchro done */ break; - case SIMIX_FAILED: - simcall->issuer->exception_ = - std::make_exception_ptr(simgrid::StorageFailureException(XBT_THROW_POINT, "Storage failed")); + case State::FAILED: + simcall->issuer_->context_->iwannadie = true; + simcall->issuer_->exception_ = + std::make_exception_ptr(StorageFailureException(XBT_THROW_POINT, "Storage failed")); + break; + case State::CANCELED: + simcall->issuer_->exception_ = std::make_exception_ptr(CancelException(XBT_THROW_POINT, "I/O Canceled")); break; - case SIMIX_CANCELED: - simcall->issuer->exception_ = - std::make_exception_ptr(simgrid::CancelException(XBT_THROW_POINT, "I/O Canceled")); + case State::TIMEOUT: + XBT_DEBUG("IoImpl::finish(): execution timeouted"); + simcall->issuer_->exception_ = std::make_exception_ptr(simgrid::TimeoutException(XBT_THROW_POINT, "Timeouted")); break; default: xbt_die("Internal error in IoImpl::finish(): unexpected synchro state %d", static_cast(state_)); } - simcall->issuer->waiting_synchro = nullptr; - if (simcall->issuer->get_host()->is_on()) - SIMIX_simcall_answer(simcall); - else - simcall->issuer->context_->iwannadie = true; + simcall->issuer_->waiting_synchro = nullptr; + simcall->issuer_->simcall_answer(); } } /************* * Callbacks * *************/ -xbt::signal IoImpl::on_start; -xbt::signal IoImpl::on_completion; +xbt::signal IoImpl::on_start; +xbt::signal IoImpl::on_completion; } // namespace activity } // namespace kernel