Intercept exit() to avoid killing simulations too early, as the first process exits.

[simgrid.git] / include / smpi / smpi.h

diff --git a/include/smpi/smpi.h b/include/smpi/smpi.h
index 69d1169..e5209d4 100644 (file)
--- a/include/smpi/smpi.h
+++ b/include/smpi/smpi.h
@@ -1141,18 +1141,22 @@ XBT_PUBLIC MPI_Comm smpi_process_comm_self();
 XBT_PUBLIC MPI_Info smpi_process_info_env();
 XBT_PUBLIC void* smpi_process_get_user_data();
 XBT_PUBLIC void smpi_process_set_user_data(void*);
+XBT_PUBLIC void smpi_init_options();
 
 XBT_PUBLIC void smpi_execute_flops(double flops);
 XBT_PUBLIC void smpi_execute_flops_benched(double flops);
 XBT_PUBLIC void smpi_execute(double duration);
 XBT_PUBLIC void smpi_execute_benched(double duration);
 
+XBT_PUBLIC void smpi_bench_begin();
+XBT_PUBLIC void smpi_bench_end();
+
 XBT_PUBLIC unsigned long long smpi_rastro_resolution();
 XBT_PUBLIC unsigned long long smpi_rastro_timestamp();
-XBT_PUBLIC void smpi_sample_1(int global, const char* file, int line, int iters, double threshold);
-XBT_PUBLIC int smpi_sample_2(int global, const char* file, int line, int iter_count);
-XBT_PUBLIC void smpi_sample_3(int global, const char* file, int line);
-XBT_PUBLIC int smpi_sample_exit(int global, const char* file, int line, int iter_count);
+XBT_PUBLIC void smpi_sample_1(int global, const char* file, const char* tag, int iters, double threshold);
+XBT_PUBLIC int smpi_sample_2(int global, const char* file, const char* tag, int iter_count);
+XBT_PUBLIC void smpi_sample_3(int global, const char* file, const char* tag);
+XBT_PUBLIC int smpi_sample_exit(int global, const char* file, const char* tag, int iter_count);
 /**
  * Need a public setter for SMPI copy_callback function, so users can define
  * their own while still using default SIMIX_copy_callback for S4U copies.
@@ -1172,7 +1176,12 @@ XBT_PUBLIC void smpi_trace_set_call_location__(const char* file, const int* line
 
 #define SMPI_ITER_NAME1(line) _XBT_CONCAT(iter_count, line)
 #define SMPI_ITER_NAME(line) SMPI_ITER_NAME1(line)
-#define SMPI_SAMPLE_LOOP(loop_init, loop_end, loop_iter, global, iters, thres)                                         \
+#define SMPI_CTAG_NAME1(line) _XBT_CONCAT(ctag, line)
+#define SMPI_CTAG_NAME(line) SMPI_CTAG_NAME1(line)
+
+#define SMPI_SAMPLE_LOOP(loop_init, loop_end, loop_iter, global, iters, thres, tag)                                    \
+  char SMPI_CTAG_NAME(__LINE__) [132];                                                                                 \
+  snprintf( SMPI_CTAG_NAME(__LINE__), 132, "%s%d", tag, __LINE__);                                                           \
   int SMPI_ITER_NAME(__LINE__) = 0;                                                                                    \
   {                                                                                                                    \
     loop_init;                                                                                                         \
@@ -1181,14 +1190,20 @@ XBT_PUBLIC void smpi_trace_set_call_location__(const char* file, const int* line
       (loop_iter);                                                                                                     \
     }                                                                                                                  \
   }                                                                                                                    \
-  for (loop_init; (loop_end) ? (smpi_sample_1((global), __FILE__, __LINE__, (iters), (thres)),                         \
-                                (smpi_sample_2((global), __FILE__, __LINE__, SMPI_ITER_NAME(__LINE__))))               \
-                             : smpi_sample_exit((global), __FILE__, __LINE__, SMPI_ITER_NAME(__LINE__));               \
-       smpi_sample_3((global), __FILE__, __LINE__), (loop_iter))
+  for ( loop_init;                                                                                                     \
+         (loop_end) ? (smpi_sample_1((global), __FILE__, SMPI_CTAG_NAME(__LINE__), (iters), (thres))                   \
+                        , (smpi_sample_2((global), __FILE__, SMPI_CTAG_NAME(__LINE__), SMPI_ITER_NAME(__LINE__))))     \
+                    : smpi_sample_exit((global), __FILE__, SMPI_CTAG_NAME(__LINE__), SMPI_ITER_NAME(__LINE__));        \
+         smpi_sample_3((global), __FILE__, SMPI_CTAG_NAME(__LINE__)), (loop_iter) )
+
 #define SMPI_SAMPLE_LOCAL(loop_init, loop_end, loop_iter, iters, thres)                                                \
-  SMPI_SAMPLE_LOOP(loop_init, (loop_end), (loop_iter), 0, (iters), (thres))
+  SMPI_SAMPLE_LOOP(loop_init, (loop_end), (loop_iter), 0, (iters), (thres), "")
+#define SMPI_SAMPLE_LOCAL_TAG(loop_init, loop_end, loop_iter, iters, thres, tag)                                       \
+  SMPI_SAMPLE_LOOP(loop_init, (loop_end), (loop_iter), 0, (iters), (thres), tag)
 #define SMPI_SAMPLE_GLOBAL(loop_init, loop_end, loop_iter, iters, thres)                                               \
-  SMPI_SAMPLE_LOOP(loop_init, (loop_end), (loop_iter), 1, (iters), (thres))
+  SMPI_SAMPLE_LOOP(loop_init, (loop_end), (loop_iter), 1, (iters), (thres), "")
+#define SMPI_SAMPLE_GLOBAL_TAG(loop_init, loop_end, loop_iter, iters, thres, tag)                                      \
+  SMPI_SAMPLE_LOOP(loop_init, (loop_end), (loop_iter), 1, (iters), (thres), tag)
 #define SMPI_SAMPLE_DELAY(duration) for(smpi_execute(duration); 0; )
 #define SMPI_SAMPLE_FLOPS(flops) for(smpi_execute_flops(flops); 0; )
 XBT_PUBLIC void* smpi_shared_malloc(size_t size, const char* file, int line);
@@ -1225,7 +1240,7 @@ XBT_PUBLIC void SMPI_thread_create();
 
 SG_END_DECL
 
-/* C++ declarations for shared_malloc */
+/* C++ declarations for shared_malloc and default copy buffer callback */
 #ifdef __cplusplus
 XBT_PUBLIC int smpi_is_shared(const void* ptr, std::vector<std::pair<size_t, size_t>>& private_blocks, size_t* offset);
 
@@ -1233,6 +1248,10 @@ std::vector<std::pair<size_t, size_t>> shift_and_frame_private_blocks(const std:
                                                                       size_t offset, size_t buff_size);
 std::vector<std::pair<size_t, size_t>> merge_private_blocks(const std::vector<std::pair<size_t, size_t>>& src,
                                                             const std::vector<std::pair<size_t, size_t>>& dst);
+
+/* May be used by S4U simulations to manually initialize SMPI */
+XBT_PUBLIC void smpi_comm_copy_buffer_callback(simgrid::kernel::activity::CommImpl* comm, void* buff,
+                                                size_t buff_size);
 #endif
 
 #endif