script:
- cmake -Denable_model-checking=OFF -Denable_documentation=OFF -Denable_coverage=ON -Denable_java=ON -Denable_lua=OFF -Denable_compile_optimizations=ON -Denable_smpi=ON -Denable_smpi_MPICH3_testsuite=ON -Denable_compile_warnings=ON .
- make VERBOSE=1 all tests && ctest --output-on-failure
+
+release:
+ only:
+ - releases
+ script:
+ - apt update && apt install -y binutils-x86-64-linux-gnu wget unzip zip
+ # Build the linux version of the jarfile without the boost dependency
+ - cmake -Denable_documentation=OFF -Denable_java=ON -Denable_lib_in_jar=ON -Dminimal_java=ON -Denable_compile_optimizations=ON -Denable_smpi=OFF .
+ - make VERBOSE=1 dist simgrid simgrid-java_jar
+ # Get the foreign architectures
+ - wget https://ci.appveyor.com/api/projects/mquinson/simgrid/artifacts/simgrid.jar -O simgrid-windows.jar
+ - export SGVER=`(echo '#include "simgrid/config.h"'; echo SIMGRID_VERSION_MAJOR.SIMGRID_VERSION_MINOR.SIMGRID_VERSION_PATCH)|gcc -E - -Iinclude|tail -1|sed 's/ //g'`
+ - wget https://ci.inria.fr/simgrid/job/SimGrid/build_mode=Debug,node=simgrid-osx-highsierra/lastSuccessfulBuild/artifact/build/SimGrid-${SGVER}/build/simgrid.jar -O simgrid-mac.jar
+ # Open all jar files, and strip them
+ - mkdir content ; cd content
+ - for j in ../simgrid.jar ../simgrid-windows.jar ../simgrid-mac.jar ; do unzip -n $j ; done
+ - strip NATIVE/*/*/*.so
+ - x86_64-linux-gnu-strip NATIVE/*/*/lib*dll
+ - zip -r ../SimGrid-${SGVER}.jar *
+ artifacts:
+ paths:
+ - SimGrid-*.jar
+ - SimGrid-*.tar.gz
set(_Boost_STACKTRACE_HEADERS "boost/stacktrace.hpp")
set(_Boost_STACKTRACE_BACKTRACE_HEADERS "boost/stacktrace.hpp")
-find_package(Boost 1.59 COMPONENTS context stacktrace_backtrace)
-set(Boost_FOUND 1) # These components are optionals
-message(STATUS "Mandatory components found. SimGrid is compilable.")
-message(STATUS "Looking for optional Boost components:")
-
-if (Boost_STACKTRACE_BACKTRACE_FOUND)
- message (STATUS " stacktrace: found. Activating human-readable stack traces.")
- set(HAVE_BOOST_STACKTRACE 1)
- set(SIMGRID_DEP "${SIMGRID_DEP} -lboost_stacktrace_backtrace")
+if(minimal_java) # When we want a minimal jarfile, don't even search for boost optional components
+ message(STATUS "Don't even look for boost optional components, as we build a minimal jar file")
else()
- message (STATUS " stacktrace: MISSING. Install libboost-stacktrace-dev to display the stacktraces.")
- set(HAVE_BOOST_STACKTRACE 0)
-endif()
+ find_package(Boost 1.59 COMPONENTS context stacktrace_backtrace)
+ set(Boost_FOUND 1) # These components are optionals
+ message(STATUS "Mandatory components found. SimGrid is compilable.")
+ message(STATUS "Looking for optional Boost components:")
+
+ if (Boost_STACKTRACE_BACKTRACE_FOUND)
+ message (STATUS " stacktrace: found. Activating human-readable stack traces.")
+ set(HAVE_BOOST_STACKTRACE 1)
+ set(SIMGRID_DEP "${SIMGRID_DEP} -lboost_stacktrace_backtrace")
+ else()
+ message (STATUS " stacktrace: MISSING. Install libboost-stacktrace-dev to display the stacktraces.")
+ set(HAVE_BOOST_STACKTRACE 0)
+ endif()
-if(Boost_CONTEXT_FOUND)
- message (STATUS " context: found. Activating Boost contexts.")
- set(HAVE_BOOST_CONTEXTS 1)
-else()
- message (STATUS " context: MISSING. Install libboost-context-dev for this optional feature.")
- set(HAVE_BOOST_CONTEXTS 0)
+ if(Boost_CONTEXT_FOUND)
+ message (STATUS " context: found. Activating Boost contexts.")
+ set(HAVE_BOOST_CONTEXTS 1)
+ else()
+ message (STATUS " context: MISSING. Install libboost-context-dev for this optional feature.")
+ set(HAVE_BOOST_CONTEXTS 0)
+ endif()
endif()
SET(SIMGRID_HAVE_MALLOCATOR 0)
endif()
-include(FindLibunwind)
-if(HAVE_LIBUNWIND)
- SET(SIMGRID_DEP "${SIMGRID_DEP} ${LIBUNWIND_LIBRARIES}")
+if (minimal_java)
+ message(STATUS "Don't look for libunwind as we build a minimal jar file.")
else()
- if(enable_model-checking)
- message(FATAL_ERROR "Please install libunwind-dev libdw-dev libelf-dev libevent-dev if you want to compile the SimGrid model checker.")
+ include(FindLibunwind)
+ if(HAVE_LIBUNWIND)
+ SET(SIMGRID_DEP "${SIMGRID_DEP} ${LIBUNWIND_LIBRARIES}")
+ else()
+ if(enable_model-checking)
+ message(FATAL_ERROR "Please install libunwind-dev libdw-dev libelf-dev libevent-dev if you want to compile the SimGrid model checker.")
+ endif()
endif()
endif()
- Tag the git repository (don't forget to push the tags to the main repo)
- Push the archive files (tar.gz and jar) on gforge
- Post a news on gforge (before updating the website)
-- Update the link scm.gforge.inria.fr:/home/groups/simgrid/htdocs/simgrid/latest
- - Create the directory of the released version and upload the doc artefact in it
- - Remove the older releases so that people don't find them in google
- Document the tag on https://github.com/simgrid/simgrid/releases and
on https://framagit.org/simgrid/simgrid/tags
- Upload the files SimGrid-3.XX.tar.gz, simgrid-3_XX.jar and
- SimGrid-doc-3_XX.zip files to the changelog.
+ SimGrid-doc-3_XX.zip (that is the artefact of the pages job on framagit) files to the changelog.
+- Update the .gitlab-ci.yml on the website
+ - Download the simgrid-doc from framagit and unpack it in position
+ - Only keep 2 versions so that people don't find older ones in google
- Rebuild and resynchronize the website so that the file gets visible
from our download page.@n
- Edit org/org-templates/level-0.org to change the release version, the tgz link and the jar link.
- Update the Docker images (after pushing to the git)
- cd tools/docker && make stable tuto-s4u push
+Release numbering semantic:
+ - 3.X is a named release.
+ - We have 4 named releases per year (for each equinox and solstice)
+ - The ChangeLog and NEWS are complete and informative
+ - All tests pass on all ci systems (or the workarounds are documented)
+ - We provide and store a source .tar.gz and a full jarfile on framagit
+ - Deprecated symbols remain usable for at least 3 named releases (~1 year)
+ - These releases are announced to the users
+ - 3.X.Y is a dot release of 3.X
+ - We provide and store a source .tar.gz and a full jarfile on framagit
+ - These releases are NOT announced publicly, nor really documented.
+ The idea is to have something close to a rolling release.
+ - External projects can depend on dot releases to loosen their
+ release process from ours, when 4 release a year is not enough
+ - 3.X.90 is a git version, a preversion of 3.(X+1) (3.22.90 = pre-3.23)
+ - No expectations on such versions
+
+Doing a dot release:
+ - Update the version number in:
+ - CMakeLists.txt (in macros SIMGRID_VERSION_*)
+ - sonar-project.properties
+ - docs/source/conf.py
+ - Commit and push to both framagit and github
+ - Wait for both appveyor and jenkins/highsierra to complete the build
+ - If it's not successful, fix it and push again
+ - Once it's successful:
+ - tag the release v3_X_Y and push the tag
+ - Merge 'master' into 'releases' and push it to framagit
+ - Do not merge into 'releases' before appveyor and jenkins are done,
+ or your jarfile will not contain the code you expect for win and
+ mac.
+
*/
/******************************* Host simcalls ********************************/
#ifdef __cplusplus
XBT_PUBLIC e_smx_state_t simcall_execution_wait(const smx_activity_t& execution);
-XBT_PUBLIC e_smx_state_t simcall_execution_test(const smx_activity_t& execution);
+XBT_PUBLIC bool simcall_execution_test(const smx_activity_t& execution);
#endif
/**************************** Process simcalls ********************************/
XBT_PUBLIC unsigned int simcall_comm_waitany(simgrid::kernel::activity::CommImpl* comms[], size_t count,
double timeout);
XBT_PUBLIC void simcall_comm_wait(const smx_activity_t& comm, double timeout);
-XBT_PUBLIC int simcall_comm_test(const smx_activity_t& comm);
+XBT_PUBLIC bool simcall_comm_test(const smx_activity_t& comm);
XBT_PUBLIC int simcall_comm_testany(smx_activity_t comms[], size_t count);
XBT_PUBLIC int simcall_comm_testany(simgrid::kernel::activity::CommImpl* comms[], size_t count);
#endif
parameter(MPI_COMM_NULL_DELETE_FN =0)
integer MPI_COMM_DUP_FN
parameter(MPI_COMM_DUP_FN =1)
- integer MPI_WIN_NULL_COPY_FN, MPI_WIN_NULL_DELETE_FN
- parameter(MPI_WIN_NULL_COPY_FN =0)
+ integer MPI_WIN_NULL_DELETE_FN
parameter(MPI_WIN_NULL_DELETE_FN =0)
- integer MPI_WIN_DUP_FN
- parameter(MPI_WIN_DUP_FN =1)
integer MPI_TYPE_NULL_COPY_FN, MPI_TYPE_NULL_DELETE_FN
parameter(MPI_TYPE_NULL_COPY_FN =0)
parameter(MPI_TYPE_NULL_DELETE_FN =0)
external MPI_BCAST, MPI_BARRIER, MPI_REDUCE, MPI_ALLREDUCE
external MPI_SCATTER, MPI_GATHER, MPI_ALLGATHER, MPI_SCAN
external MPI_ALLTOALL, MPI_GATHERV, MPI_SENDRECV
+ external MPI_WIN_DUP_FN, MPI_WIN_NULL_COPY_FN
external MPI_WTIME
external MPI_WTICK
namespace activity {
ActivityImpl::~ActivityImpl()
+{
+ clean_action();
+ XBT_DEBUG("Destroy activity %p", this);
+}
+
+void ActivityImpl::clean_action()
{
if (surf_action_) {
surf_action_->unref();
- XBT_DEBUG("Destroy activity %p", this);
surf_action_ = nullptr;
}
}
XBT_VERB("Activity %p is canceled", this);
if (surf_action_ != nullptr)
surf_action_->cancel();
+ state_ = SIMIX_CANCELED;
}
// boost::intrusive_ptr<Activity> support:
virtual void post() = 0; // What to do when a simcall terminates
virtual void finish() = 0;
+ virtual void clean_action();
virtual double get_remaining() const;
// boost::intrusive_ptr<ActivityImpl> support:
friend XBT_PUBLIC void intrusive_ptr_add_ref(ActivityImpl* activity);
void simcall_HANDLER_comm_test(smx_simcall_t simcall, simgrid::kernel::activity::CommImpl* comm)
{
- int res;
+ bool res;
if (MC_is_active() || MC_record_replay_is_active()) {
res = comm->src_actor_ && comm->dst_actor_;
/** @brief This is part of the cleanup process, probably an internal command */
void CommImpl::cleanupSurf()
{
- if (surf_action_) {
- surf_action_->unref();
- surf_action_ = nullptr;
- }
+ clean_action();
if (src_timeout_) {
src_timeout_->unref();
CommImpl& set_type(CommImpl::Type type);
CommImpl& set_size(double size);
- double get_rate() { return rate_; }
- CommImpl& set_rate(double rate);
CommImpl& set_src_buff(void* buff, size_t size);
CommImpl& set_dst_buff(void* buff, size_t* size);
+ CommImpl& set_rate(double rate);
+ double get_rate() { return rate_; }
- CommImpl* start();
void copy_data();
+
+ CommImpl* start();
void suspend() override;
void resume() override;
+ void cancel() override;
void post() override;
void finish() override;
- void cancel() override;
CommImpl::Type type_; /* Type of the communication (SIMIX_COMM_SEND or SIMIX_COMM_RECEIVE) */
MailboxImpl* mbox = nullptr; /* Rendez-vous where the comm is queued */
void simcall_HANDLER_execution_test(smx_simcall_t simcall, simgrid::kernel::activity::ExecImpl* synchro)
{
- int res = (synchro->state_ != SIMIX_WAITING && synchro->state_ != SIMIX_RUNNING);
+ bool res = (synchro->state_ != SIMIX_WAITING && synchro->state_ != SIMIX_RUNNING);
if (res) {
synchro->simcalls_.push_back(simcall);
synchro->finish();
on_completion(*this);
- if (surf_action_) {
- surf_action_->unref();
- surf_action_ = nullptr;
- }
+ clean_action();
+
if (timeout_detector_) {
timeout_detector_->unref();
timeout_detector_ = nullptr;
SIMIX_simcall_answer(simcall);
}
}
- SIMIX_process_sleep_destroy(this);
+
+ clean_action();
}
} // namespace activity
} // namespace kernel
if (exec != nullptr && exec->surf_action_) {
exec->cancel();
- exec->surf_action_->unref();
- exec->surf_action_ = nullptr;
+ exec->clean_action();
} else if (comm != nullptr) {
comms.remove(waiting_synchro);
comm->cancel();
if (i != waiting_synchro->simcalls_.end())
waiting_synchro->simcalls_.remove(&simcall);
} else if (sleep != nullptr) {
- if (sleep->surf_action_)
- sleep->surf_action_->cancel();
- sleep->post();
+ sleep->cancel();
+ sleep->finish();
} else if (raw != nullptr) {
raw->finish();
} else if (io != nullptr) {
io->cancel();
+ io->finish();
} else {
simgrid::kernel::activity::ActivityImplPtr activity = waiting_synchro;
xbt_die("Activity is of unknown type %s", simgrid::xbt::demangle(typeid(activity).name()).get());
activity::SleepImplPtr sleep = boost::dynamic_pointer_cast<activity::SleepImpl>(waiting_synchro);
if (sleep != nullptr) {
- SIMIX_process_sleep_destroy(sleep);
+ sleep->clean_action();
if (std::find(begin(simix_global->actors_to_run), end(simix_global->actors_to_run), this) ==
end(simix_global->actors_to_run) &&
this != SIMIX_process_self()) {
simgrid::kernel::activity::SleepImplPtr sleep =
boost::dynamic_pointer_cast<simgrid::kernel::activity::SleepImpl>(actor->waiting_synchro);
if (sleep != nullptr) {
- SIMIX_process_sleep_destroy(sleep);
+ sleep->clean_action();
if (std::find(begin(simix_global->actors_to_run), end(simix_global->actors_to_run), actor) ==
end(simix_global->actors_to_run) &&
actor != SIMIX_process_self()) {
simcall->issuer->waiting_synchro = sync;
}
-void SIMIX_process_sleep_destroy(simgrid::kernel::activity::SleepImplPtr sleep)
-{
- XBT_DEBUG("Destroy sleep synchro %p", sleep.get());
-
- if (sleep->surf_action_) {
- sleep->surf_action_->unref();
- sleep->surf_action_ = nullptr;
- }
-}
-
/**
* @brief Calling this function makes the process to yield.
*
extern void (*SMPI_switch_data_segment)(simgrid::s4u::ActorPtr actor);
-XBT_PRIVATE void SIMIX_process_sleep_destroy(simgrid::kernel::activity::SleepImplPtr synchro);
-
#endif
return (e_smx_state_t)simcall_BODY_execution_wait(static_cast<simgrid::kernel::activity::ExecImpl*>(execution.get()));
}
-e_smx_state_t simcall_execution_test(const smx_activity_t& execution)
+bool simcall_execution_test(const smx_activity_t& execution)
{
- return (e_smx_state_t)simcall_BODY_execution_test(static_cast<simgrid::kernel::activity::ExecImpl*>(execution.get()));
+ return simcall_BODY_execution_test(static_cast<simgrid::kernel::activity::ExecImpl*>(execution.get()));
}
void simcall_process_join(smx_actor_t process, double timeout)
* @ingroup simix_comm_management
*
*/
-int simcall_comm_test(const smx_activity_t& comm)
+bool simcall_comm_test(const smx_activity_t& comm)
{
return simcall_BODY_comm_test(static_cast<simgrid::kernel::activity::CommImpl*>(comm.get()));
}
{
simgrid::simix::marshal<simgrid::kernel::activity::ExecImpl*>(simcall->args[0], arg);
}
-static inline int simcall_execution_test__get__result(smx_simcall_t simcall)
+static inline bool simcall_execution_test__get__result(smx_simcall_t simcall)
{
- return simgrid::simix::unmarshal<int>(simcall->result);
+ return simgrid::simix::unmarshal<bool>(simcall->result);
}
-static inline int simcall_execution_test__getraw__result(smx_simcall_t simcall)
+static inline bool simcall_execution_test__getraw__result(smx_simcall_t simcall)
{
- return simgrid::simix::unmarshal_raw<int>(simcall->result);
+ return simgrid::simix::unmarshal_raw<bool>(simcall->result);
}
-static inline void simcall_execution_test__set__result(smx_simcall_t simcall, int result)
+static inline void simcall_execution_test__set__result(smx_simcall_t simcall, bool result)
{
- simgrid::simix::marshal<int>(simcall->result, result);
+ simgrid::simix::marshal<bool>(simcall->result, result);
}
static inline smx_actor_t simcall_comm_send__get__sender(smx_simcall_t simcall)
{
simgrid::simix::marshal<simgrid::kernel::activity::CommImpl*>(simcall->args[0], arg);
}
-static inline int simcall_comm_test__get__result(smx_simcall_t simcall)
+static inline bool simcall_comm_test__get__result(smx_simcall_t simcall)
{
- return simgrid::simix::unmarshal<int>(simcall->result);
+ return simgrid::simix::unmarshal<bool>(simcall->result);
}
-static inline int simcall_comm_test__getraw__result(smx_simcall_t simcall)
+static inline bool simcall_comm_test__getraw__result(smx_simcall_t simcall)
{
- return simgrid::simix::unmarshal_raw<int>(simcall->result);
+ return simgrid::simix::unmarshal_raw<bool>(simcall->result);
}
-static inline void simcall_comm_test__set__result(smx_simcall_t simcall, int result)
+static inline void simcall_comm_test__set__result(smx_simcall_t simcall, bool result)
{
- simgrid::simix::marshal<int>(simcall->result, result);
+ simgrid::simix::marshal<bool>(simcall->result, result);
}
static inline simgrid::kernel::activity::CommImpl** simcall_comm_testany__get__comms(smx_simcall_t simcall)
return simcall<int, simgrid::kernel::activity::ExecImpl*>(SIMCALL_EXECUTION_WAIT, execution);
}
-inline static int simcall_BODY_execution_test(simgrid::kernel::activity::ExecImpl* execution)
+inline static bool simcall_BODY_execution_test(simgrid::kernel::activity::ExecImpl* execution)
{
if (0) /* Go to that function to follow the code flow through the simcall barrier */
simcall_HANDLER_execution_test(&SIMIX_process_self()->simcall, execution);
- return simcall<int, simgrid::kernel::activity::ExecImpl*>(SIMCALL_EXECUTION_TEST, execution);
+ return simcall<bool, simgrid::kernel::activity::ExecImpl*>(SIMCALL_EXECUTION_TEST, execution);
}
inline static void simcall_BODY_comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout)
return simcall<void, simgrid::kernel::activity::CommImpl*, double>(SIMCALL_COMM_WAIT, comm, timeout);
}
-inline static int simcall_BODY_comm_test(simgrid::kernel::activity::CommImpl* comm)
+inline static bool simcall_BODY_comm_test(simgrid::kernel::activity::CommImpl* comm)
{
if (0) /* Go to that function to follow the code flow through the simcall barrier */
simcall_HANDLER_comm_test(&SIMIX_process_self()->simcall, comm);
- return simcall<int, simgrid::kernel::activity::CommImpl*>(SIMCALL_COMM_TEST, comm);
+ return simcall<bool, simgrid::kernel::activity::CommImpl*>(SIMCALL_COMM_TEST, comm);
}
inline static int simcall_BODY_comm_testany(simgrid::kernel::activity::CommImpl** comms, size_t count)
int process_sleep(double duration) [[block]];
int execution_wait(simgrid::kernel::activity::ExecImpl* execution) [[block]];
-int execution_test(simgrid::kernel::activity::ExecImpl* execution) [[block]];
+bool execution_test(simgrid::kernel::activity::ExecImpl* execution) [[block]];
void comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double timeout) [[block]];
boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm_isend(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff, size_t src_buff_size, simix_match_func_t match_fun, simix_clean_func_t clean_fun, simix_copy_data_func_t copy_data_fun, void* data, bool detached);
boost::intrusive_ptr<simgrid::kernel::activity::ActivityImpl> comm_irecv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size, simix_match_func_t match_fun, simix_copy_data_func_t copy_data_fun, void* data, double rate);
int comm_waitany(simgrid::kernel::activity::CommImpl** comms, size_t count, double timeout) [[block]];
void comm_wait(simgrid::kernel::activity::CommImpl* comm, double timeout) [[block]];
-int comm_test(simgrid::kernel::activity::CommImpl* comm) [[block]];
+bool comm_test(simgrid::kernel::activity::CommImpl* comm) [[block]];
int comm_testany(simgrid::kernel::activity::CommImpl** comms, size_t count) [[block]];
void mutex_lock(smx_mutex_t mutex) [[block]];
# smx_host_t h)
if self.simcalls_pre is None:
self.simcalls_pre = set()
- for fn in glob.glob('smx_*') + glob.glob('ActorImpl*') + \
+ for fn in glob.glob('smx_*') + glob.glob('../kernel/actor/ActorImpl*') + \
glob.glob('../mc/*cpp') + glob.glob('../kernel/activity/*cpp'):
f = open(fn)
self.simcalls_pre |= set(re.findall(r'simcall_HANDLER_(.*?)\(', f.read()))
}
}
-void mpi_win_get_attr_(int* win, int* type_keyval, int* attribute_val, int* flag, int* ierr){
- int* value = nullptr;
+void mpi_win_get_attr_(int* win, int* type_keyval, MPI_Aint* attribute_val, int* flag, int* ierr){
+ MPI_Aint* value = nullptr;
*ierr = MPI_Win_get_attr(simgrid::smpi::Win::f2c(*win), *type_keyval, &value, flag);
if (*flag == 1)
*attribute_val = *value;
}
-void mpi_win_set_attr_(int* win, int* type_keyval, int* att, int* ierr){
- int* val = (int*)xbt_malloc(sizeof(int));
+void mpi_win_set_attr_(int* win, int* type_keyval, MPI_Aint* att, int* ierr){
+ MPI_Aint* val = (MPI_Aint*)xbt_malloc(sizeof(MPI_Aint));
*val=*att;
*ierr = MPI_Win_set_attr(simgrid::smpi::Win::f2c(*win), *type_keyval, val);
}
*ierr = MPI_Win_flush_local_all(simgrid::smpi::Win::f2c(*win));
}
+void mpi_win_null_copy_fn_( int* win, int* keyval, int* extrastate, MPI_Aint* valin, MPI_Aint* valout,
+ int* flag, int* ierr ){
+ *flag=0;
+ *ierr=MPI_SUCCESS;
+}
+
+void mpi_win_dup_fn_( int* win, int* keyval, int* extrastate, MPI_Aint* valin, MPI_Aint* valout,
+ int* flag, int* ierr ){
+ *flag=1;
+ *valout=*valin;
+ *ierr=MPI_SUCCESS;
+}
+
void mpi_info_create_( int *info, int* ierr){
MPI_Info tmp;
*ierr = MPI_Info_create(&tmp);
void mpi_alltoallw_ ( void *sendbuf, int *sendcnts, int *sdispls, int* old_sendtypes, void *recvbuf, int *recvcnts,
int *rdispls, int* old_recvtypes, int* comm, int* ierr){
int size = simgrid::smpi::Comm::f2c(*comm)->size();
- sendbuf = static_cast<char *>( FORT_IN_PLACE(sendbuf));
MPI_Datatype* sendtypes = new MPI_Datatype[size];
MPI_Datatype* recvtypes = new MPI_Datatype[size];
for(int i=0; i< size; i++){
- sendtypes[i] = simgrid::smpi::Datatype::f2c(old_sendtypes[i]);
+ if(FORT_IN_PLACE(sendbuf)!=MPI_IN_PLACE)
+ sendtypes[i] = simgrid::smpi::Datatype::f2c(old_sendtypes[i]);
recvtypes[i] = simgrid::smpi::Datatype::f2c(old_recvtypes[i]);
}
+ sendbuf = static_cast<char *>( FORT_IN_PLACE(sendbuf));
*ierr = MPI_Alltoallw( sendbuf, sendcnts, sdispls, sendtypes, recvbuf, recvcnts, rdispls,
recvtypes, simgrid::smpi::Comm::f2c(*comm));
delete[] sendtypes;
int *rdispls, int* old_recvtypes, int* comm, int* request, int* ierr){
MPI_Request req;
int size = simgrid::smpi::Comm::f2c(*comm)->size();
- sendbuf = static_cast<char *>( FORT_IN_PLACE(sendbuf));
MPI_Datatype* sendtypes = new MPI_Datatype[size];
MPI_Datatype* recvtypes = new MPI_Datatype[size];
for(int i=0; i< size; i++){
- sendtypes[i] = simgrid::smpi::Datatype::f2c(old_sendtypes[i]);
+ if(FORT_IN_PLACE(sendbuf)!=MPI_IN_PLACE)
+ sendtypes[i] = simgrid::smpi::Datatype::f2c(old_sendtypes[i]);
recvtypes[i] = simgrid::smpi::Datatype::f2c(old_recvtypes[i]);
}
+ sendbuf = static_cast<char *>( FORT_IN_PLACE(sendbuf));
*ierr = MPI_Ialltoallw( sendbuf, sendcnts, sdispls, sendtypes, recvbuf, recvcnts, rdispls,
recvtypes, simgrid::smpi::Comm::f2c(*comm), &req);
if(*ierr == MPI_SUCCESS) {
int PMPI_Win_get_attr (MPI_Win win, int keyval, void *attribute_val, int* flag)
{
static MPI_Aint size;
- static int disp_unit;
+ static MPI_Aint disp_unit;
if (win==MPI_WIN_NULL)
return MPI_ERR_TYPE;
else{
return MPI_SUCCESS;
case MPI_WIN_DISP_UNIT :
disp_unit=win->disp_unit();
- *static_cast<int**>(attribute_val) = &disp_unit;
+ *static_cast<MPI_Aint**>(attribute_val) = &disp_unit;
*flag = 1;
return MPI_SUCCESS;
default:
MPI_Comm comm)
{
//non commutative case, use a working algo from openmpi
- if (op != MPI_OP_NULL && not op->is_commutative()) {
+ if (op != MPI_OP_NULL && (datatype->flags() & DT_FLAG_DERIVED || not op->is_commutative())) {
return Coll_reduce_ompi_basic_linear::reduce(sendbuf, recvbuf, count, datatype, op, root, comm);
}
MPI_Request request;
int Coll_allreduce_default::allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
{
+ //FIXME: have mpi_ireduce and iallreduce handle derived datatypes correctly
+ if(datatype->flags() & DT_FLAG_DERIVED)
+ return Coll_allreduce_ompi::allreduce(sendbuf, recvbuf, count, datatype, op, comm);
int ret;
ret = Coll_reduce_default::reduce(sendbuf, recvbuf, count, datatype, op, 0, comm);
if(ret==MPI_SUCCESS)
void mpi_win_set_info_(int* win, int* info, int* ierr);
void mpi_win_get_info_(int* win, int* info, int* ierr);
void mpi_win_get_group_(int* win, int* group, int* ierr);
-void mpi_win_get_attr_(int* win, int* type_keyval, int* attribute_val, int* flag, int* ierr);
-void mpi_win_set_attr_(int* win, int* type_keyval, int* att, int* ierr);
+void mpi_win_get_attr_(int* win, int* type_keyval, MPI_Aint* attribute_val, int* flag, int* ierr);
+void mpi_win_set_attr_(int* win, int* type_keyval, MPI_Aint* att, int* ierr);
void mpi_win_delete_attr_(int* win, int* comm_keyval, int* ierr);
void mpi_win_create_keyval_(void* copy_fn, void* delete_fn, int* keyval, void* extra_state, int* ierr);
void mpi_win_free_keyval_(int* keyval, int* ierr);
void mpi_win_flush_local_(int* rank, int* win, int* ierr);
void mpi_win_flush_all_(int* win, int* ierr);
void mpi_win_flush_local_all_(int* win, int* ierr);
+void mpi_win_dup_fn_( int* win, int* keyval, int* extrastate, MPI_Aint* valin, MPI_Aint* valout, int* flag, int* ierr );
+void mpi_win_null_copy_fn_( int* win, int* keyval, int* extrastate, MPI_Aint* valin, MPI_Aint* valout, int* flag, int* ierr );
void mpi_info_create_(int* info, int* ierr);
void mpi_info_set_(int* info, char* key, char* value, int* ierr, unsigned int keylen, unsigned int valuelen);
void mpi_info_free_(int* info, int* ierr);
. MPI_SUM, comm, req, ierr)
call MPI_Wait(req, MPI_STATUS_IGNORE, ierr)
+ call MPI_Iscatter(sbuf, NUM_INTS, MPI_INTEGER, rbuf,
+ . NUM_INTS, MPI_INTEGER, 0, comm, req, ierr)
+ call MPI_Wait(req, MPI_STATUS_IGNORE, ierr)
+
+ call MPI_Iscatterv(sbuf, scounts, sdispls, MPI_INTEGER,
+ . rbuf, NUM_INTS, MPI_INTEGER,
+ . 0, comm, req, ierr)
+ call MPI_Wait(req, MPI_STATUS_IGNORE, ierr)
+
+ call MPI_Iallgather(sbuf, NUM_INTS, MPI_INTEGER,
+ . rbuf, NUM_INTS, MPI_INTEGER, comm, req, ierr)
+ call MPI_Wait(req, MPI_STATUS_IGNORE, ierr)
+
+ call MPI_Iallgatherv(sbuf, NUM_INTS, MPI_INTEGER,
+ . rbuf, rcounts, rdispls, MPI_INTEGER,
+ . comm, req, ierr)
+ call MPI_Wait(req, MPI_STATUS_IGNORE, ierr)
+
call mtest_finalize( errs )
call MPI_Finalize( ierr )
end
include_directories(BEFORE "${CMAKE_HOME_DIRECTORY}/include/smpi")
foreach(test winaccf
- # winerrf
- winfencef wingroupf
- # baseattrwinf winattr2f winattrf
- wingetf winnamef winscale1f
- # winscale2f
- )
+ winfencef wingroupf
+ baseattrwinf winattr2f winattrf
+ wingetf winnamef winscale1f
+ # winscale2f winerrf
+ )
add_executable(${test} EXCLUDE_FROM_ALL ${test}.f)
add_dependencies(tests ${test})
target_link_libraries(${test} simgrid mtest_f77)
C (C) 2003 by Argonne National Laboratory.
C See COPYRIGHT in top-level directory.
C
- integer extrastate, valin, valout, val
+ integer(kind=MPI_ADDRESS_KIND) extrastate, valin, valout, val
wingroupf 4 needs_privatization=1
winaccf 4 needs_privatization=1
c2f2cwinf 1
-#baseattrwinf 1
-#winattrf 1
-#winattr2f 1
+baseattrwinf 1
+winattrf 1
+winattr2f 1
foreach(test winaccf90
# winerrf90
- winfencef90 wingroupf90
- # baseattrwinf90 winattr2f90 winattrf90
- wingetf90 winnamef90 winscale1f90
- # winscale2f90
- )
+ winfencef90 wingroupf90
+ baseattrwinf90 winattr2f90 winattrf90
+ wingetf90 winnamef90 winscale1f90
+ # winscale2f90
+ )
add_executable(${test} EXCLUDE_FROM_ALL ${test}.f90)
add_dependencies(tests ${test})
target_link_libraries(${test} simgrid mtest_f90)
wingroupf90 4 needs_privatization=1
winaccf90 4 needs_privatization=1
c2f2cwinf90 1
-#baseattrwinf90 1
-#winattrf90 1
-#winattr2f90 1
+baseattrwinf90 1
+winattrf90 1
+winattr2f90 1
option(enable_ns3 "Whether ns3 model is activated." off)
option(enable_java "Whether the Java bindings are activated." off)
option(enable_lib_in_jar "Whether the native libraries are bundled in a Java jar file" on)
+option(minimal_java "Whether to compile the jarfile with the minimal dependency set" off)
+mark_as_advanced(minimal_java)
+if(minimal_java)
+ set(enable_java on)
+ set(enable_lib_in_jar on)
+endif()
option(enable_lua "Whether the Lua bindings are activated." off)
chrpath \
libdw-dev libevent-dev libunwind8-dev \
&& \
- pip3 install breathe javasphinx sphinx>=1.8.0b1 sphinx_rtd_theme
+ pip3 install breathe javasphinx 'sphinx>=1.8.0b1' sphinx_rtd_theme
\ No newline at end of file
