XBT_PUBLIC(sg_size_t) simcall_file_read(surf_file_t fd, sg_size_t size, sg_host_t host);
XBT_PUBLIC(sg_size_t) simcall_file_write(surf_file_t fd, sg_size_t size, sg_host_t host);
XBT_PUBLIC(surf_file_t) simcall_file_open(const char* mount, const char* path, sg_storage_t st);
-XBT_PUBLIC(int) simcall_file_close(surf_file_t fd, sg_host_t host);
/************************** MC simcalls **********************************/
XBT_PUBLIC(int) simcall_mc_random(int min, int max);
simcall_file_open__set__result(simcall, tmp);
break;
}
- case SIMCALL_FILE_CLOSE:
- delete simcall_file_close__get__fd(simcall);
- simcall_file_close__set__result(simcall, 0);
- break;
case SIMCALL_FILE_WRITE:
simcall_file_write__set__result(simcall, surf_io->getCost());
break;
File::~File()
{
- simcall_file_close(pimpl_, host_);
+ simgrid::simix::kernelImmediate([this] { delete pimpl_; });
}
sg_size_t File::read(sg_size_t size)
return simcall_BODY_file_open(mount, path, st);
}
-/**
- * \ingroup simix_file_management
- *
- */
-int simcall_file_close(surf_file_t fd, sg_host_t host)
-{
- return simcall_BODY_file_close(fd, host);
-}
-
void simcall_run_kernel(std::function<void()> const& code)
{
simcall_BODY_run_kernel(&code);
simgrid::simix::marshal<surf_file_t>(simcall->result, result);
}
-static inline surf_file_t simcall_file_close__get__fd(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]);
-}
-static inline surf_file_t simcall_file_close__getraw__fd(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<surf_file_t>(simcall->args[0]);
-}
-static inline void simcall_file_close__set__fd(smx_simcall_t simcall, surf_file_t arg)
-{
- simgrid::simix::marshal<surf_file_t>(simcall->args[0], arg);
-}
-static inline sg_host_t simcall_file_close__get__host(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]);
-}
-static inline sg_host_t simcall_file_close__getraw__host(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<sg_host_t>(simcall->args[1]);
-}
-static inline void simcall_file_close__set__host(smx_simcall_t simcall, sg_host_t arg)
-{
- simgrid::simix::marshal<sg_host_t>(simcall->args[1], arg);
-}
-static inline int simcall_file_close__get__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal<int>(simcall->result);
-}
-static inline int simcall_file_close__getraw__result(smx_simcall_t simcall)
-{
- return simgrid::simix::unmarshal_raw<int>(simcall->result);
-}
-static inline void simcall_file_close__set__result(smx_simcall_t simcall, int result){
- simgrid::simix::marshal<int>(simcall->result, result);
-}
-
static inline int simcall_mc_random__get__min(smx_simcall_t simcall)
{
return simgrid::simix::unmarshal<int>(simcall->args[0]);
XBT_PRIVATE void simcall_HANDLER_file_read(smx_simcall_t simcall, surf_file_t fd, sg_size_t size, sg_host_t host);
XBT_PRIVATE void simcall_HANDLER_file_write(smx_simcall_t simcall, surf_file_t fd, sg_size_t size, sg_host_t host);
XBT_PRIVATE void simcall_HANDLER_file_open(smx_simcall_t simcall, const char* mount, const char* path, sg_storage_t st);
-XBT_PRIVATE void simcall_HANDLER_file_close(smx_simcall_t simcall, surf_file_t fd, sg_host_t host);
XBT_PRIVATE int simcall_HANDLER_mc_random(smx_simcall_t simcall, int min, int max);
\ No newline at end of file
return simcall<surf_file_t, const char*, const char*, sg_storage_t>(SIMCALL_FILE_OPEN, mount, path, st);
}
- inline static int simcall_BODY_file_close(surf_file_t fd, sg_host_t host)
- {
- /* Go to that function to follow the code flow through the simcall barrier */
- if (0) simcall_HANDLER_file_close(&SIMIX_process_self()->simcall, fd, host);
- return simcall<int, surf_file_t, sg_host_t>(SIMCALL_FILE_CLOSE, fd, host);
- }
-
inline static int simcall_BODY_mc_random(int min, int max) {
/* Go to that function to follow the code flow through the simcall barrier */
if (0) simcall_HANDLER_mc_random(&SIMIX_process_self()->simcall, min, max);
SIMCALL_FILE_READ,
SIMCALL_FILE_WRITE,
SIMCALL_FILE_OPEN,
- SIMCALL_FILE_CLOSE,
SIMCALL_MC_RANDOM,
SIMCALL_SET_CATEGORY,
SIMCALL_RUN_KERNEL,
"SIMCALL_FILE_READ",
"SIMCALL_FILE_WRITE",
"SIMCALL_FILE_OPEN",
- "SIMCALL_FILE_CLOSE",
"SIMCALL_MC_RANDOM",
"SIMCALL_SET_CATEGORY",
"SIMCALL_RUN_KERNEL",
simgrid::simix::unmarshal<sg_storage_t>(simcall->args[2]));
break;
-case SIMCALL_FILE_CLOSE:
- simcall_HANDLER_file_close(simcall, simgrid::simix::unmarshal<surf_file_t>(simcall->args[0]),
- simgrid::simix::unmarshal<sg_host_t>(simcall->args[1]));
- break;
-
case SIMCALL_MC_RANDOM:
simgrid::simix::marshal<int>(simcall->result, simcall_HANDLER_mc_random(simcall, simgrid::simix::unmarshal<int>(simcall->args[0]), simgrid::simix::unmarshal<int>(simcall->args[1])));
SIMIX_simcall_answer(simcall);
sg_size_t file_read(surf_file_t fd, sg_size_t size, sg_host_t host) [[block]];
sg_size_t file_write(surf_file_t fd, sg_size_t size, sg_host_t host) [[block]];
surf_file_t file_open(const char* mount, const char* path, sg_storage_t st) [[block]];
-int file_close(surf_file_t fd, sg_host_t host) [[block]];
int mc_random(int min, int max);
void set_category(boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> synchro, const char* category) [[nohandler]];
return synchro;
}
-//SIMIX FILE CLOSE
-void simcall_HANDLER_file_close(smx_simcall_t simcall, surf_file_t fd, sg_host_t host)
-{
- smx_activity_t synchro = SIMIX_file_close(fd, host);
- synchro->simcalls.push_back(simcall);
- simcall->issuer->waiting_synchro = synchro;
-}
-
-smx_activity_t SIMIX_file_close(surf_file_t file, sg_host_t host)
-{
- if (host->isOff())
- THROWF(host_error, 0, "Host %s failed, you cannot call this function", host->getCname());
-
- simgrid::kernel::activity::IoImpl* synchro = new simgrid::kernel::activity::IoImpl();
- synchro->host = host;
- synchro->surf_io = host->pimpl_->close(file);
- synchro->surf_io->setData(synchro);
- XBT_DEBUG("Create io synchro %p", synchro);
-
- return synchro;
-}
-
void SIMIX_io_destroy(smx_activity_t synchro)
{
simgrid::kernel::activity::IoImplPtr io = boost::static_pointer_cast<simgrid::kernel::activity::IoImpl>(synchro);
storages->push_back(s.second->piface_.getName());
}
-Action* HostImpl::close(surf_file_t fd)
-{
- simgrid::surf::StorageImpl* st = findStorageOnMountList(fd->mount());
- XBT_DEBUG("CLOSE %s on disk '%s'", fd->cname(), st->cname());
- return st->close(fd);
-}
-
Action* HostImpl::read(surf_file_t fd, sg_size_t size)
{
simgrid::surf::StorageImpl* st = findStorageOnMountList(fd->mount());
/** @brief Get the xbt_dynar_t of storages attached to the Host */
virtual void getAttachedStorageList(std::vector<const char*>* storages);
- /**
- * @brief Close a file
- *
- * @param fd The file descriptor to close
- * @return The StorageAction corresponding to the closing
- */
- virtual Action* close(surf_file_t fd);
-
/**
* @brief Read a file
*
*/
virtual StorageAction* open(const char* mount, const char* path) = 0;
- /**
- * @brief Close a file
- *
- * @param fd The file descriptor to close
- * @return The StorageAction corresponding to the closing
- */
- virtual StorageAction* close(surf_file_t fd) = 0;
-
/**
* @brief Read a file
*
return action;
}
-StorageAction *StorageN11::close(surf_file_t fd)
-{
- XBT_DEBUG("\tClose file '%s' size '%llu'", fd->cname(), fd->size());
- StorageAction* action = new StorageN11Action(model(), 0, isOff(), this, CLOSE);
- return action;
-}
-
StorageAction *StorageN11::read(surf_file_t fd, sg_size_t size)
{
if (fd->tell() + size > fd->size()) {
lmm_expand(model->getMaxminSystem(), storage->constraint(), getVariable(), 1.0);
switch(type) {
case OPEN:
- case CLOSE:
+ break;
case READ:
lmm_expand(model->getMaxminSystem(), storage->constraintRead_, getVariable(), 1.0);
break;
const char* type_id, char* content_name, sg_size_t size, char* attach);
virtual ~StorageN11() = default;
StorageAction *open(const char* mount, const char* path);
- StorageAction *close(surf_file_t fd);
StorageAction *ls(const char *path);
StorageAction* read(surf_file_t fd, sg_size_t size);
StorageAction* write(surf_file_t fd, sg_size_t size);