X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3b2a4637c63acb5ffa7e48bc17cf0ec92ad5d539..0afab0e550e09d35a4aaaae802c7f2ea17d2b860:/src/smpi/private.h diff --git a/src/smpi/private.h b/src/smpi/private.h index 770c63c29f..108ace8520 100644 --- a/src/smpi/private.h +++ b/src/smpi/private.h @@ -1,99 +1,307 @@ +/* Copyright (c) 2007, 2009, 2010. 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. */ + #ifndef SMPI_PRIVATE_H #define SMPI_PRIVATE_H -#include "xbt/mallocator.h" +#include "xbt.h" #include "xbt/xbt_os_time.h" -#include "smpi.h" - -#define SMPI_DEFAULT_SPEED 100 -#define SMPI_REQUEST_MALLOCATOR_SIZE 100 -#define SMPI_MESSAGE_MALLOCATOR_SIZE 100 - -typedef struct smpi_mpi_communicator_simdata { - smx_host_t *hosts; - smx_process_t *processes; - int barrier_count; - smx_mutex_t barrier_mutex; - smx_cond_t barrier_cond; -} s_smpi_mpi_communicator_simdata_t; - -typedef struct smpi_mpi_request_simdata { - smx_mutex_t mutex; - smx_cond_t cond; -} s_smpi_mpi_request_simdata_t; - -typedef struct SMPI_Global { - - // config vars - double reference_speed; - - // state vars - int root_ready:1; - int ready_process_count; - smx_mutex_t start_stop_mutex; - smx_cond_t start_stop_cond; - - xbt_mallocator_t request_mallocator; - xbt_mallocator_t message_mallocator; - - xbt_fifo_t *pending_send_request_queues; - smx_mutex_t *pending_send_request_queues_mutexes; - - xbt_fifo_t *pending_recv_request_queues; - smx_mutex_t *pending_recv_request_queues_mutexes; - - xbt_fifo_t *received_message_queues; - smx_mutex_t *received_message_queues_mutexes; - - smx_process_t *sender_processes; - smx_process_t *receiver_processes; - - int running_hosts_count; - smx_mutex_t running_hosts_count_mutex; - - xbt_os_timer_t *timers; - smx_mutex_t *timers_mutexes; - -} s_SMPI_Global_t, *SMPI_Global_t; -extern SMPI_Global_t smpi_global; - -struct smpi_received_message_t { - smpi_mpi_communicator_t *comm; - int src; - int dst; - int tag; - void *buf; -}; -typedef struct smpi_received_message_t smpi_received_message_t; - -// function prototypes -int smpi_mpi_comm_size(smpi_mpi_communicator_t *comm); -int smpi_mpi_comm_rank(smpi_mpi_communicator_t *comm, smx_host_t host); -int smpi_mpi_comm_rank_self(smpi_mpi_communicator_t *comm); -int smpi_mpi_comm_world_rank_self(void); -int smpi_sender(int argc, char **argv); -int smpi_receiver(int argc, char **argv); -void *smpi_request_new(void); -void smpi_request_free(void *pointer); -void smpi_request_reset(void *pointer); -void *smpi_message_new(void); -void smpi_message_free(void *pointer); -void smpi_message_reset(void *pointer); +#include "simgrid/simix.h" +#include "smpi/smpi.h" +#include "smpi/smpif.h" +#include "smpi/smpi_cocci.h" +#include "instr/instr_private.h" + +struct s_smpi_process_data; +typedef struct s_smpi_process_data *smpi_process_data_t; + +#define PERSISTENT 0x1 +#define NON_PERSISTENT 0x2 +#define SEND 0x4 +#define RECV 0x8 + + +//***************************************************************************************** + +// this struct is here to handle the problem of non-contignous data +// for each such structure these function should be implemented (vector +// index hvector hindex struct) +typedef struct s_smpi_subtype{ + void (*serialize)(const void * input, void *output, size_t count, void* subtype); + void (*unserialize)(const void * input, void *output, size_t count, void* subtype); +} s_smpi_subtype_t; + +/*one exemple of implementation for the vector is already here*/ +typedef struct s_smpi_mpi_vector{ + s_smpi_subtype_t base; + size_t block_stride; + size_t block_length; + size_t block_count; + MPI_Datatype old_type; + size_t size_oldtype; +} s_smpi_mpi_vector_t; + +typedef struct s_smpi_mpi_datatype{ + size_t size; + /* this let us know if a serialization is required*/ + size_t has_subtype; + MPI_Aint lb; + MPI_Aint ub; + int flags; + /* this let us know how to serialize and unserialize*/ + void *substruct; +} s_smpi_mpi_datatype_t; + + +//***************************************************************************************** + +typedef struct s_smpi_mpi_request { + void *buf; + /* in the case of non-contignous memory the user address shoud be keep + * to unserialize the data inside the user memory*/ + void *old_buf; + /* this let us know how tounserialize at the end of + * the communication*/ + MPI_Datatype old_type; + size_t size; + int src; + int dst; + int tag; + MPI_Comm comm; + smx_action_t action; + unsigned flags; +#ifdef HAVE_TRACING + int send; + int recv; +#endif +} s_smpi_mpi_request_t; + +void smpi_process_init(int *argc, char ***argv); +void smpi_process_destroy(void); +void smpi_process_finalize(void); + +smpi_process_data_t smpi_process_data(void); +smpi_process_data_t smpi_process_remote_data(int index); +void smpi_process_set_user_data(void *); +void* smpi_process_get_user_data(void); +int smpi_process_count(void); +smx_rdv_t smpi_process_mailbox(void); +smx_rdv_t smpi_process_remote_mailbox(int index); +smx_rdv_t smpi_process_mailbox_small(void); +smx_rdv_t smpi_process_remote_mailbox_small(int index); +xbt_os_timer_t smpi_process_timer(void); +void smpi_process_simulated_start(void); +double smpi_process_simulated_elapsed(void); + +void print_request(const char *message, MPI_Request request); + void smpi_global_init(void); void smpi_global_destroy(void); -int smpi_run_simulation(int argc, char **argv); -void smpi_mpi_land_func(void *x, void *y, void *z); -void smpi_mpi_sum_func(void *x, void *y, void *z); -void smpi_mpi_init(void); -void smpi_mpi_finalize(void); + +size_t smpi_datatype_size(MPI_Datatype datatype); +MPI_Aint smpi_datatype_lb(MPI_Datatype datatype); +MPI_Aint smpi_datatype_ub(MPI_Datatype datatype); +int smpi_datatype_extent(MPI_Datatype datatype, MPI_Aint * lb, + MPI_Aint * extent); +int smpi_datatype_copy(void *sendbuf, int sendcount, MPI_Datatype sendtype, + void *recvbuf, int recvcount, + MPI_Datatype recvtype); +int smpi_datatype_contiguous(int count, MPI_Datatype old_type, + MPI_Datatype* new_type); +int smpi_datatype_vector(int count, int blocklen, int stride, + MPI_Datatype old_type, MPI_Datatype* new_type); + +int smpi_datatype_hvector(int count, int blocklen, MPI_Aint stride, + MPI_Datatype old_type, MPI_Datatype* new_type); +int smpi_datatype_indexed(int count, int* blocklens, int* indices, + MPI_Datatype old_type, MPI_Datatype* new_type); +int smpi_datatype_hindexed(int count, int* blocklens, MPI_Aint* indices, + MPI_Datatype old_type, MPI_Datatype* new_type); +int smpi_datatype_struct(int count, int* blocklens, MPI_Aint* indices, + MPI_Datatype* old_types, MPI_Datatype* new_type); + +void smpi_datatype_create(MPI_Datatype* new_type, int size, int has_subtype, void *struct_type, int flags); + + +void smpi_datatype_free(MPI_Datatype* type); +void smpi_datatype_commit(MPI_Datatype* datatype); + + +void smpi_empty_status(MPI_Status * status); +MPI_Op smpi_op_new(MPI_User_function * function, int commute); +void smpi_op_destroy(MPI_Op op); +void smpi_op_apply(MPI_Op op, void *invec, void *inoutvec, int *len, + MPI_Datatype * datatype); + +MPI_Group smpi_group_new(int size); +void smpi_group_destroy(MPI_Group group); +void smpi_group_set_mapping(MPI_Group group, int index, int rank); +int smpi_group_index(MPI_Group group, int rank); +int smpi_group_rank(MPI_Group group, int index); +int smpi_group_use(MPI_Group group); +int smpi_group_unuse(MPI_Group group); +int smpi_group_size(MPI_Group group); +int smpi_group_compare(MPI_Group group1, MPI_Group group2); + +MPI_Comm smpi_comm_new(MPI_Group group); +void smpi_comm_destroy(MPI_Comm comm); +MPI_Group smpi_comm_group(MPI_Comm comm); +int smpi_comm_size(MPI_Comm comm); +void smpi_comm_get_name(MPI_Comm comm, char* name, int* len); +int smpi_comm_rank(MPI_Comm comm); +MPI_Comm smpi_comm_split(MPI_Comm comm, int color, int key); + +MPI_Request smpi_mpi_send_init(void *buf, int count, MPI_Datatype datatype, + int dst, int tag, MPI_Comm comm); +MPI_Request smpi_mpi_recv_init(void *buf, int count, MPI_Datatype datatype, + int src, int tag, MPI_Comm comm); +void smpi_mpi_start(MPI_Request request); +void smpi_mpi_startall(int count, MPI_Request * requests); +void smpi_mpi_request_free(MPI_Request * request); +MPI_Request smpi_isend_init(void *buf, int count, MPI_Datatype datatype, + int dst, int tag, MPI_Comm comm); +MPI_Request smpi_mpi_isend(void *buf, int count, MPI_Datatype datatype, + int dst, int tag, MPI_Comm comm); +MPI_Request smpi_irecv_init(void *buf, int count, MPI_Datatype datatype, + int src, int tag, MPI_Comm comm); +MPI_Request smpi_mpi_irecv(void *buf, int count, MPI_Datatype datatype, + int src, int tag, MPI_Comm comm); +void smpi_mpi_recv(void *buf, int count, MPI_Datatype datatype, int src, + int tag, MPI_Comm comm, MPI_Status * status); +void smpi_mpi_send(void *buf, int count, MPI_Datatype datatype, int dst, + int tag, MPI_Comm comm); +void smpi_mpi_sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, + int dst, int sendtag, void *recvbuf, int recvcount, + MPI_Datatype recvtype, int src, int recvtag, + MPI_Comm comm, MPI_Status * status); +int smpi_mpi_test(MPI_Request * request, MPI_Status * status); +int smpi_mpi_testany(int count, MPI_Request requests[], int *index, + MPI_Status * status); +int smpi_mpi_testall(int count, MPI_Request requests[], + MPI_Status status[]); +void smpi_mpi_probe(int source, int tag, MPI_Comm comm, MPI_Status* status); +void smpi_mpi_iprobe(int source, int tag, MPI_Comm comm, int* flag, + MPI_Status* status); +int smpi_mpi_get_count(MPI_Status * status, MPI_Datatype datatype); +void smpi_mpi_wait(MPI_Request * request, MPI_Status * status); +int smpi_mpi_waitany(int count, MPI_Request requests[], + MPI_Status * status); +void smpi_mpi_waitall(int count, MPI_Request requests[], + MPI_Status status[]); +int smpi_mpi_waitsome(int incount, MPI_Request requests[], int *indices, + MPI_Status status[]); +int smpi_mpi_testsome(int incount, MPI_Request requests[], int *indices, + MPI_Status status[]); +void smpi_mpi_bcast(void *buf, int count, MPI_Datatype datatype, int root, + MPI_Comm comm); +void smpi_mpi_barrier(MPI_Comm comm); +void smpi_mpi_gather(void *sendbuf, int sendcount, MPI_Datatype sendtype, + void *recvbuf, int recvcount, MPI_Datatype recvtype, + int root, MPI_Comm comm); +void smpi_mpi_gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, + void *recvbuf, int *recvcounts, int *displs, + MPI_Datatype recvtype, int root, MPI_Comm comm); +void smpi_mpi_allgather(void *sendbuf, int sendcount, + MPI_Datatype sendtype, void *recvbuf, + int recvcount, MPI_Datatype recvtype, + MPI_Comm comm); +void smpi_mpi_allgatherv(void *sendbuf, int sendcount, + MPI_Datatype sendtype, void *recvbuf, + int *recvcounts, int *displs, + MPI_Datatype recvtype, MPI_Comm comm); +void smpi_mpi_scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype, + void *recvbuf, int recvcount, MPI_Datatype recvtype, + int root, MPI_Comm comm); +void smpi_mpi_scatterv(void *sendbuf, int *sendcounts, int *displs, + MPI_Datatype sendtype, void *recvbuf, int recvcount, + MPI_Datatype recvtype, int root, MPI_Comm comm); +void smpi_mpi_reduce(void *sendbuf, void *recvbuf, int count, + MPI_Datatype datatype, MPI_Op op, int root, + MPI_Comm comm); +void smpi_mpi_allreduce(void *sendbuf, void *recvbuf, int count, + MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); +void smpi_mpi_scan(void *sendbuf, void *recvbuf, int count, + MPI_Datatype datatype, MPI_Op op, MPI_Comm comm); + +void nary_tree_bcast(void *buf, int count, MPI_Datatype datatype, int root, + MPI_Comm comm, int arity); +void nary_tree_barrier(MPI_Comm comm, int arity); + +int smpi_coll_tuned_alltoall_bruck(void *sendbuf, int sendcount, + MPI_Datatype sendtype, void *recvbuf, + int recvcount, MPI_Datatype recvtype, + MPI_Comm comm); +int smpi_coll_tuned_alltoall_basic_linear(void *sendbuf, int sendcount, + MPI_Datatype sendtype, + void *recvbuf, int recvcount, + MPI_Datatype recvtype, + MPI_Comm comm); +int smpi_coll_tuned_alltoall_pairwise(void *sendbuf, int sendcount, + MPI_Datatype sendtype, void *recvbuf, + int recvcount, MPI_Datatype recvtype, + MPI_Comm comm); +int smpi_coll_basic_alltoallv(void *sendbuf, int *sendcounts, + int *senddisps, MPI_Datatype sendtype, + void *recvbuf, int *recvcounts, + int *recvdisps, MPI_Datatype recvtype, + MPI_Comm comm); + +// utilities +void smpi_bench_destroy(void); void smpi_bench_begin(void); void smpi_bench_end(void); -void smpi_barrier(smpi_mpi_communicator_t *comm); -int smpi_comm_rank(smpi_mpi_communicator_t *comm, smx_host_t host); -int smpi_create_request(void *buf, int count, smpi_mpi_datatype_t *datatype, - int src, int dst, int tag, smpi_mpi_communicator_t *comm, smpi_mpi_request_t **request); -int smpi_isend(smpi_mpi_request_t *request); -int smpi_irecv(smpi_mpi_request_t *request); -void smpi_wait(smpi_mpi_request_t *request, smpi_mpi_status_t *status); +void smpi_execute_flops(double flops); + +// f77 wrappers +void mpi_init__(int*); +void mpi_finalize__(int*); +void mpi_abort__(int* comm, int* errorcode, int* ierr); +void mpi_comm_rank__(int* comm, int* rank, int* ierr); +void mpi_comm_size__(int* comm, int* size, int* ierr); +double mpi_wtime__(void); + +void mpi_comm_dup__(int* comm, int* newcomm, int* ierr); +void mpi_comm_split__(int* comm, int* color, int* key, int* comm_out, int* ierr); + +void mpi_send_init__(void *buf, int* count, int* datatype, int* dst, int* tag, + int* comm, int* request, int* ierr); +void mpi_isend__(void *buf, int* count, int* datatype, int* dst, + int* tag, int* comm, int* request, int* ierr); +void mpi_send__(void* buf, int* count, int* datatype, int* dst, + int* tag, int* comm, int* ierr); +void mpi_recv_init__(void *buf, int* count, int* datatype, int* src, int* tag, + int* comm, int* request, int* ierr); +void mpi_irecv__(void *buf, int* count, int* datatype, int* src, int* tag, + int* comm, int* request, int* ierr); +void mpi_recv__(void* buf, int* count, int* datatype, int* src, + int* tag, int* comm, MPI_Status* status, int* ierr); +void mpi_start__(int* request, int* ierr); +void mpi_startall__(int* count, int* requests, int* ierr); +void mpi_wait__(int* request, MPI_Status* status, int* ierr); +void mpi_waitany__(int* count, int* requests, int* index, MPI_Status* status, int* ierr); +void mpi_waitall__(int* count, int* requests, MPI_Status* status, int* ierr); + +void mpi_barrier__(int* comm, int* ierr); +void mpi_bcast__(void* buf, int* count, int* datatype, int* root, int* comm, int* ierr); +void mpi_reduce__(void* sendbuf, void* recvbuf, int* count, + int* datatype, int* op, int* root, int* comm, int* ierr); +void mpi_allreduce__(void* sendbuf, void* recvbuf, int* count, int* datatype, + int* op, int* comm, int* ierr); +void mpi_scatter__(void* sendbuf, int* sendcount, int* sendtype, + void* recvbuf, int* recvcount, int* recvtype, + int* root, int* comm, int* ierr); +void mpi_gather__(void* sendbuf, int* sendcount, int* sendtype, + void* recvbuf, int* recvcount, int* recvtype, + int* root, int* comm, int* ierr); +void mpi_allgather__(void* sendbuf, int* sendcount, int* sendtype, + void* recvbuf, int* recvcount, int* recvtype, + int* comm, int* ierr); +void mpi_scan__(void* sendbuf, void* recvbuf, int* count, int* datatype, + int* op, int* comm, int* ierr); +void mpi_alltoall__(void* sendbuf, int* sendcount, int* sendtype, + void* recvbuf, int* recvcount, int* recvtype, int* comm, int* ierr); #endif