}
namespace kernel {
namespace activity {
- class Synchro;
+ class ActivityImpl;
}
namespace routing {
class NetCard;
typedef simgrid::s4u::As simgrid_As;
typedef simgrid::s4u::Host simgrid_Host;
typedef boost::intrusive_ptr<simgrid::s4u::Mailbox> sg_mbox_t;
-typedef simgrid::kernel::activity::Synchro simgrid_Synchro;
+typedef simgrid::kernel::activity::ActivityImpl kernel_Activity;
typedef simgrid::kernel::routing::NetCard routing_NetCard;
typedef simgrid::surf::Cpu surf_Cpu;
typedef simgrid::surf::Link Link;
typedef struct simgrid_As simgrid_As;
typedef struct simgrid_Host simgrid_Host;
typedef struct simgrid_Mailbox *sg_mbox_t;
-typedef struct simgrid_Synchro simgrid_Synchro;
+typedef struct kernel_Activity kernel_Activity;
typedef struct surf_Cpu surf_Cpu;
typedef struct routing_NetCard routing_NetCard;
typedef struct surf_Resource surf_Resource;
typedef simgrid_As *AS_t;
typedef simgrid_Host* sg_host_t;
-typedef simgrid_Synchro *smx_synchro_t;
+typedef kernel_Activity *smx_synchro_t;
typedef surf_Cpu *surf_cpu_t;
typedef routing_NetCard *sg_netcard_t;
void *getUserData() { return userData_; }
private:
- simgrid::kernel::activity::Synchro *pimpl_ = nullptr;
+ simgrid::kernel::activity::ActivityImpl *pimpl_ = nullptr;
e_s4u_activity_state_t state_ = inited;
double remains_ = 0;
void *userData_ = nullptr;
I wait_any(I first, I last)
{
// Map to dynar<Synchro*>:
- xbt_dynar_t comms = xbt_dynar_new(sizeof(simgrid::kernel::activity::Synchro*), NULL);
+ xbt_dynar_t comms = xbt_dynar_new(sizeof(simgrid::kernel::activity::ActivityImpl*), NULL);
for(I iter = first; iter != last; iter++) {
Comm& comm = **iter;
if (comm.state_ == inited)
comm.start();
xbt_assert(comm.state_ == started);
- xbt_dynar_push_as(comms, simgrid::kernel::activity::Synchro*, comm.pimpl_);
+ xbt_dynar_push_as(comms, simgrid::kernel::activity::ActivityImpl*, comm.pimpl_);
}
// Call the underlying simcall:
int idx = simcall_comm_waitany(comms, -1);
I wait_any_for(I first, I last, double timeout)
{
// Map to dynar<Synchro*>:
- xbt_dynar_t comms = xbt_dynar_new(sizeof(simgrid::kernel::activity::Synchro*), NULL);
+ xbt_dynar_t comms = xbt_dynar_new(sizeof(simgrid::kernel::activity::ActivityImpl*), NULL);
for(I iter = first; iter != last; iter++) {
Comm& comm = **iter;
if (comm.state_ == inited)
comm.start();
xbt_assert(comm.state_ == started);
- xbt_dynar_push_as(comms, simgrid::kernel::activity::Synchro*, comm.pimpl_);
+ xbt_dynar_push_as(comms, simgrid::kernel::activity::ActivityImpl*, comm.pimpl_);
}
// Call the underlying simcall:
int idx = simcall_comm_waitany(comms, timeout);
--- /dev/null
+/* Copyright (c) 2007-2016. The SimGrid Team. All rights reserved. */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
+#include "src/kernel/activity/ActivityImpl.hpp"
+
+simgrid::kernel::activity::ActivityImpl::ActivityImpl()
+{
+}
+
+simgrid::kernel::activity::ActivityImpl::~ActivityImpl()
+{
+}
+
+void simgrid::kernel::activity::ActivityImpl::ref()
+{
+ refcount++;
+}
+
+void simgrid::kernel::activity::ActivityImpl::unref()
+{
+ xbt_assert(refcount > 0,
+ "This activity has a negative refcount! You can only call test() or wait() once per activity.");
+
+ refcount--;
+ if (refcount>0)
+ return;
+ delete this;
+}
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#ifndef _SIMIX_SYNCHRO_HPP
-#define _SIMIX_SYNCHRO_HPP
+#ifndef SIMGRID_KERNEL_ACTIVITY_ACTIVITYIMPL_HPP
+#define SIMGRID_KERNEL_ACTIVITY_ACTIVITYIMPL_HPP
#include <string>
#include <list>
#include <xbt/base.h>
#include "simgrid/forward.h"
-#ifdef __cplusplus
-
#include <simgrid/simix.hpp>
namespace simgrid {
namespace kernel {
namespace activity {
- XBT_PUBLIC_CLASS Synchro {
+ XBT_PUBLIC_CLASS ActivityImpl {
public:
- Synchro();
- virtual ~Synchro();
- e_smx_state_t state = SIMIX_WAITING; /* State of the synchro */
- std::string name; /* synchro name if any */
- std::list<smx_simcall_t> simcalls; /* List of simcalls waiting for this synchro */
+ ActivityImpl();
+ virtual ~ActivityImpl();
+ e_smx_state_t state = SIMIX_WAITING; /* State of the activity */
+ std::string name; /* Activity name if any */
+ std::list<smx_simcall_t> simcalls; /* List of simcalls waiting for this activity */
virtual void suspend()=0;
virtual void resume()=0;
int refcount = 1;
};
}}} // namespace simgrid::kernel::activity
-#else /* not C++ */
-
-
-#endif
-#endif
+#endif /* SIMGRID_KERNEL_ACTIVITY_ACTIVITYIMPL_HPP */
+++ /dev/null
-/* Copyright (c) 2007-2016. The SimGrid Team. All rights reserved. */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#include "src/kernel/activity/Synchro.h"
-
-simgrid::kernel::activity::Synchro::Synchro()
-{
-}
-
-simgrid::kernel::activity::Synchro::~Synchro()
-{
-}
-
-void simgrid::kernel::activity::Synchro::ref()
-{
- refcount++;
-}
-
-void simgrid::kernel::activity::Synchro::unref()
-{
- xbt_assert(refcount > 0,
- "This synchro has a negative refcount! You can only call test() or wait() once per synchronization.");
-
- refcount--;
- if (refcount>0)
- return;
- delete this;
-}
#define _SIMIX_SYNCHRO_COMM_HPP
#include "surf/surf.h"
-#include "src/kernel/activity/Synchro.h"
+#include "src/kernel/activity/ActivityImpl.hpp"
typedef enum {
SIMIX_COMM_SEND,
namespace kernel {
namespace activity {
- XBT_PUBLIC_CLASS Comm : public Synchro {
+ XBT_PUBLIC_CLASS Comm : public ActivityImpl {
~Comm() override;
public:
explicit Comm(e_smx_comm_type_t type);
#define _SIMIX_SYNCHRO_EXEC_HPP
#include "surf/surf.h"
-#include "src/kernel/activity/Synchro.h"
+#include "src/kernel/activity/ActivityImpl.hpp"
namespace simgrid {
namespace kernel {
namespace activity {
- XBT_PUBLIC_CLASS Exec : public Synchro {
+ XBT_PUBLIC_CLASS Exec : public ActivityImpl {
~Exec() override;
public:
Exec(const char*name, sg_host_t host);
#define _SIMIX_SYNCHRO_IO_HPP
#include "surf/surf.h"
-#include "src/kernel/activity/Synchro.h"
+#include "src/kernel/activity/ActivityImpl.hpp"
namespace simgrid {
namespace kernel {
namespace activity {
- XBT_PUBLIC_CLASS Io : public Synchro {
+ XBT_PUBLIC_CLASS Io : public ActivityImpl {
public:
void suspend() override;
void resume() override;
#define _SIMIX_SYNCHRO_RAW_HPP
#include "surf/surf.h"
-#include "src/kernel/activity/Synchro.h"
+#include "src/kernel/activity/ActivityImpl.hpp"
namespace simgrid {
namespace kernel {
namespace activity {
/** Used to implement mutexes, semaphores and conditions */
- XBT_PUBLIC_CLASS Raw : public Synchro {
+ XBT_PUBLIC_CLASS Raw : public ActivityImpl {
public:
~Raw() override;
void suspend() override;
#define _SIMIX_SYNCHRO_SLEEP_HPP
#include "surf/surf.h"
-#include "src/kernel/activity/Synchro.h"
+#include "src/kernel/activity/ActivityImpl.hpp"
namespace simgrid {
namespace kernel {
namespace activity {
- XBT_PUBLIC_CLASS Sleep : public Synchro {
+ XBT_PUBLIC_CLASS Sleep : public ActivityImpl {
public:
void suspend() override;
void resume() override;
#include "mc/mc.h"
#include "src/mc/mc_protocol.h"
-#include "src/kernel/activity/Synchro.h"
+#include "src/kernel/activity/ActivityImpl.hpp"
#include "src/kernel/activity/SynchroIo.hpp"
#include "src/kernel/activity/SynchroComm.hpp"
#include "src/kernel/activity/SynchroRaw.hpp"
int finished_index = -1;
/* Create the equivalent array with SIMIX objects: */
- std::vector<simgrid::kernel::activity::Synchro*> s_comms;
+ std::vector<simgrid::kernel::activity::ActivityImpl*> s_comms;
s_comms.reserve(xbt_dynar_length(comms));
msg_comm_t comm;
unsigned int cursor;
smx_synchro_t SIMIX_process_join(smx_process_t issuer, smx_process_t process, double timeout)
{
smx_synchro_t res = SIMIX_process_sleep(issuer, timeout);
- static_cast<simgrid::kernel::activity::Synchro*>(res)->ref();
+ static_cast<simgrid::kernel::activity::ActivityImpl*>(res)->ref();
SIMIX_process_on_exit(process, (int_f_pvoid_pvoid_t)SIMIX_process_join_finish, res);
return res;
}
}
void simcall_HANDLER_comm_testany(
- smx_simcall_t simcall, simgrid::kernel::activity::Synchro* comms[], size_t count)
+ smx_simcall_t simcall, simgrid::kernel::activity::ActivityImpl* comms[], size_t count)
{
// The default result is -1 -- this means, "nothing is ready".
// It can be changed below, but only if something matches.
if(idx == -1){
SIMIX_simcall_answer(simcall);
}else{
- simgrid::kernel::activity::Synchro* synchro = comms[idx];
+ simgrid::kernel::activity::ActivityImpl* synchro = comms[idx];
simcall_comm_testany__set__result(simcall, idx);
synchro->simcalls.push_back(simcall);
synchro->state = SIMIX_DONE;
}
for (std::size_t i = 0; i != count; ++i) {
- simgrid::kernel::activity::Synchro* synchro = comms[i];
+ simgrid::kernel::activity::ActivityImpl* synchro = comms[i];
if (synchro->state != SIMIX_WAITING && synchro->state != SIMIX_RUNNING) {
simcall_comm_testany__set__result(simcall, i);
synchro->simcalls.push_back(simcall);
int smpi_mpi_testany(int count, MPI_Request requests[], int *index, MPI_Status * status)
{
- std::vector<simgrid::kernel::activity::Synchro*> comms;
+ std::vector<simgrid::kernel::activity::ActivityImpl*> comms;
comms.reserve(count);
int i;
src/simix/smx_private.h
src/simix/ActorImpl.hpp
src/simix/smx_synchro_private.h
- src/kernel/activity/Synchro.h
+ src/kernel/activity/ActivityImpl.hpp
src/kernel/activity/SynchroComm.hpp
src/kernel/activity/SynchroExec.hpp
src/kernel/activity/SynchroIo.hpp
src/simix/smx_synchro.cpp
src/simix/smx_vm.cpp
src/simix/popping.cpp
- src/kernel/activity/Synchro.cpp
+ src/kernel/activity/ActivityImpl.cpp
src/kernel/activity/SynchroComm.cpp
src/kernel/activity/SynchroExec.cpp
src/kernel/activity/SynchroSleep.cpp