X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8a70fd6e0cc77910dda2e50a7f8bbb864f26c0b9..272ccad1b68b6d9c17069f3c934886925bb15b5d:/src/gras/Msg/sg_msg.c diff --git a/src/gras/Msg/sg_msg.c b/src/gras/Msg/sg_msg.c index 7da6665099..78d510d990 100644 --- a/src/gras/Msg/sg_msg.c +++ b/src/gras/Msg/sg_msg.c @@ -7,20 +7,19 @@ * under the terms of the license (GNU LGPL) which comes with this package. */ #include "xbt/ex.h" - +#include "xbt/xbt_socket_private.h" /* FIXME */ +#include "xbt/datadesc.h" +#include "xbt/datadesc/datadesc_interface.h" /* FIXME */ #include "gras/Virtu/virtu_sg.h" - #include "gras/Msg/msg_private.h" - -#include "gras/DataDesc/datadesc_interface.h" #include "gras/Transport/transport_interface.h" /* gras_trp_chunk_send/recv */ #include "gras/Transport/transport_private.h" /* sock->data */ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(gras_msg); typedef void *gras_trp_bufdata_; -#include "simix/datatypes.h" -#include "simix/private.h" +#include "simgrid/simix.h" +#include "simix/smx_private.h" /* Yeah, the following is awfull, breaking the encapsulation of at least 3 modules * at the same time, but I'm tracking this bug since too long now, I want it dead. now. @@ -33,7 +32,8 @@ typedef struct { smx_process_t s_process; } *fake_xbt_thread_t; -int gras_socket_im_the_server(gras_socket_t sock) { +int gras_socket_im_the_server(xbt_socket_t sock) +{ gras_trp_sg_sock_data_t sock_data = sock->data; gras_procdata_t* pd; gras_msg_listener_t l; @@ -41,17 +41,17 @@ int gras_socket_im_the_server(gras_socket_t sock) { smx_process_t server_listener_process=NULL; smx_process_t client_listener_process = NULL; - VERB4("Am I the server of socket %p (client = %p, server = %p) ? process self: %p", sock, sock_data->client, sock_data->server, SIMIX_process_self()); + XBT_VERB("Am I the server of socket %p (client = %p, server = %p) ? process self: %p", sock, sock_data->client, sock_data->server, SIMIX_process_self()); if (sock_data->server == SIMIX_process_self()) { - VERB0("I am the server"); + XBT_VERB("I am the server"); return 1; } if (sock_data->client == SIMIX_process_self()) { - VERB0("I am the client"); + XBT_VERB("I am the client"); return 0; } - VERB0("I am neither the client nor the server, probably a listener"); + XBT_VERB("I am neither the client nor the server, probably a listener"); /* neither the client nor the server. Check their respective listeners */ pd = ((gras_procdata_t*)SIMIX_process_get_data(sock_data->server)); @@ -60,7 +60,7 @@ int gras_socket_im_the_server(gras_socket_t sock) { listener_thread = ((fake_gras_msg_listener_t)l)->listener; server_listener_process = ((fake_xbt_thread_t)listener_thread)->s_process; if (server_listener_process == SIMIX_process_self()) { - VERB0("I am the listener of the server"); + XBT_VERB("I am the listener of the server"); return 1; } } @@ -72,7 +72,7 @@ int gras_socket_im_the_server(gras_socket_t sock) { listener_thread = ((fake_gras_msg_listener_t)l)->listener; client_listener_process = ((fake_xbt_thread_t)listener_thread)->s_process; if (client_listener_process == SIMIX_process_self()) { - VERB0("I am the listener of the client"); + XBT_VERB("I am the listener of the client"); return 0; } } @@ -82,11 +82,11 @@ int gras_socket_im_the_server(gras_socket_t sock) { xbt_backtrace_display_current(); ((char*)sock)[sizeof(*sock)+1] = '0'; /* Try to make valgrind angry to see where that damn socket comes from */ if(system(bprintf("cat /proc/%d/maps 1>&2",getpid()))){} - INFO6("I'm not the client in socket %p (comm:%p, rdvser=%p, rdvcli=%p) to %s, that's %s", + XBT_INFO("I'm not the client in socket %p (comm:%p, rdvser=%p, rdvcli=%p) to %s, that's %s", sock,sock_data->comm_recv,sock_data->rdv_server,sock_data->rdv_client, SIMIX_host_get_name(SIMIX_process_get_host(sock_data->server)), sock_data->client?SIMIX_host_get_name(SIMIX_process_get_host(sock_data->client)):"(no client)"); - INFO7("server:%s (%p) server_listener=%p client:%s (%p) client_listener=%p, I'm %p", + XBT_INFO("server:%s (%p) server_listener=%p client:%s (%p) client_listener=%p, I'm %p", SIMIX_host_get_name(SIMIX_process_get_host(sock_data->server)), sock_data->server,server_listener_process, sock_data->client?SIMIX_host_get_name(SIMIX_process_get_host(sock_data->client)):"(no client)", sock_data->client,client_listener_process, SIMIX_process_self()); @@ -103,13 +103,13 @@ gras_msg_t gras_msg_recv_any(void) xbt_dynar_t comms = xbt_dynar_new(sizeof(smx_action_t), NULL); unsigned int cursor = 0; int got = 0; - gras_socket_t sock = NULL; + xbt_socket_t sock = NULL; gras_trp_sg_sock_data_t sock_data; xbt_dynar_foreach(trp_proc->sockets, cursor, sock) { sock_data = (gras_trp_sg_sock_data_t) sock->data; - DEBUG5 + XBT_DEBUG ("Consider socket %p (data:%p; Here rdv: %p; Remote rdv: %p; Comm %p) to get a message", sock, sock_data, gras_socket_im_the_server(sock)? @@ -146,12 +146,12 @@ gras_msg_t gras_msg_recv_any(void) * an iterator, incremented only when the socket has a comm. And we've the right socket * when that iterator is equal to "got", the result of waitany. Not needed if B holds. */ - xbt_assert1(sock_data->comm_recv, + xbt_assert(sock_data->comm_recv, "Comm_recv of socket %p is empty; please report that nasty bug", sock); /* End of paranoia */ - VERB3("Consider receiving messages from on comm_recv %p rdv:%p (other rdv:%p)", + XBT_VERB("Consider receiving messages from on comm_recv %p rdv:%p (other rdv:%p)", sock_data->comm_recv, gras_socket_im_the_server(sock)? sock_data->rdv_server : sock_data->rdv_client, @@ -159,15 +159,15 @@ gras_msg_t gras_msg_recv_any(void) sock_data->rdv_client : sock_data->rdv_server); xbt_dynar_push(comms, &(sock_data->comm_recv)); } - VERB1("Wait on %ld 'sockets'", xbt_dynar_length(comms)); + XBT_VERB("Wait on %lu 'sockets'", xbt_dynar_length(comms)); /* Wait for the end of any of these communications */ - got = SIMIX_req_comm_waitany(comms); + got = simcall_comm_waitany(comms); /* retrieve the message sent in that communication */ - sock = xbt_dynar_get_as(trp_proc->sockets, got, gras_socket_t); + sock = xbt_dynar_get_as(trp_proc->sockets, got, xbt_socket_t); sock_data = (gras_trp_sg_sock_data_t) sock->data; msg = sock_data->msg; - VERB2("Got something. Communication over rdv_server=%p, rdv_client=%p", + XBT_VERB("Got something. Communication over rdv_server=%p, rdv_client=%p", sock_data->rdv_server,sock_data->rdv_client); /* Reinstall a waiting communication on that rdv */ @@ -178,7 +178,7 @@ gras_msg_t gras_msg_recv_any(void) } */ sock_data->comm_recv = - SIMIX_req_comm_irecv(gras_socket_im_the_server(sock) ? + simcall_comm_irecv(gras_socket_im_the_server(sock) ? sock_data->rdv_server : sock_data->rdv_client, &sock_data->msg, NULL, NULL, NULL); @@ -186,7 +186,7 @@ gras_msg_t gras_msg_recv_any(void) } -void gras_msg_send_ext(gras_socket_t sock, +void gras_msg_send_ext(xbt_socket_t sock, e_gras_msg_kind_t kind, unsigned long int ID, gras_msgtype_t msgtype, void *payload) @@ -209,38 +209,69 @@ void gras_msg_send_ext(gras_socket_t sock, msg->kind = kind; msg->type = msgtype; msg->ID = ID; - - VERB4("Send msg %s (%s) to rdv %p sock %p", + XBT_PUBLIC(xbt_datadesc_type_t) xbt_datadesc_by_id(long int code); + + /* to debug */ + XBT_PUBLIC(void) xbt_datadesc_type_dump(const xbt_datadesc_type_t ddt); + XBT_PUBLIC(const char *) xbt_datadesc_arch_name(int code); + + /* compare two data type description */ + XBT_PUBLIC(int) + xbt_datadesc_type_cmp(const xbt_datadesc_type_t d1, + const xbt_datadesc_type_t d2); + + /* Access function */ + XBT_PUBLIC(int) xbt_datadesc_size(xbt_datadesc_type_t type); + /* Described data exchanges: direct use */ + XBT_PUBLIC(int) xbt_datadesc_memcpy(xbt_datadesc_type_t type, void *src, + void *dst); + XBT_PUBLIC(void) xbt_datadesc_send(xbt_socket_t sock, + xbt_datadesc_type_t type, void *src); + XBT_PUBLIC(void) xbt_datadesc_recv(xbt_socket_t sock, + xbt_datadesc_type_t type, int r_arch, + void *dst); + + /* Described data exchanges: IDL compilation FIXME: not implemented*/ + void xbt_datadesc_gen_cpy(xbt_datadesc_type_t type, void *src, + void **dst); + void xbt_datadesc_gen_send(xbt_socket_t sock, + xbt_datadesc_type_t type, void *src); + void xbt_datadesc_gen_recv(xbt_socket_t sock, + xbt_datadesc_type_t type, int r_arch, + void *dst); + + + XBT_VERB("Send msg %s (%s) to rdv %p sock %p", msgtype->name, e_gras_msg_kind_names[kind], target_rdv, sock); if (kind == e_gras_msg_kind_rpcerror) { /* error on remote host, careful, payload is an exception */ - msg->payl_size = gras_datadesc_size(gras_datadesc_by_name("ex_t")); + msg->payl_size = xbt_datadesc_size(xbt_datadesc_by_name("ex_t")); msg->payl = xbt_malloc(msg->payl_size); whole_payload_size = - gras_datadesc_memcpy(gras_datadesc_by_name("ex_t"), payload, + xbt_datadesc_memcpy(xbt_datadesc_by_name("ex_t"), payload, msg->payl); } else if (kind == e_gras_msg_kind_rpcanswer) { - msg->payl_size = gras_datadesc_size(msgtype->answer_type); + msg->payl_size = xbt_datadesc_size(msgtype->answer_type); if (msg->payl_size) msg->payl = xbt_malloc(msg->payl_size); else msg->payl = NULL; if (msgtype->answer_type) - whole_payload_size = gras_datadesc_memcpy(msgtype->answer_type, + whole_payload_size = xbt_datadesc_memcpy(msgtype->answer_type, payload, msg->payl); } else { - msg->payl_size = gras_datadesc_size(msgtype->ctn_type); + msg->payl_size = xbt_datadesc_size(msgtype->ctn_type); msg->payl = msg->payl_size ? xbt_malloc(msg->payl_size) : NULL; if (msgtype->ctn_type) - whole_payload_size = gras_datadesc_memcpy(msgtype->ctn_type, + whole_payload_size = xbt_datadesc_memcpy(msgtype->ctn_type, payload, msg->payl); } - comm = SIMIX_req_comm_isend(target_rdv, whole_payload_size, -1, msg, sizeof(void *), NULL, msg, 0); - SIMIX_req_comm_wait(comm, -1); + comm = simcall_comm_isend(target_rdv, whole_payload_size, -1, msg, sizeof(void *), NULL,NULL, msg, 0); + simcall_comm_wait(comm, -1); - VERB0("Message sent (and received)"); + XBT_VERB("Message sent (and received)"); }