X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3473014423f69b4ec6ecaddca3f3c9e503a7adbf..4a9f96113bc9372624cefc06d484a8943bea9992:/src/gras/Msg/sg_msg.c diff --git a/src/gras/Msg/sg_msg.c b/src/gras/Msg/sg_msg.c index 2a9c84a7b6..4e32910f68 100644 --- a/src/gras/Msg/sg_msg.c +++ b/src/gras/Msg/sg_msg.c @@ -1,8 +1,7 @@ -/* $Id$ */ - /* messaging - Function related to messaging code specific to SG */ -/* Copyright (c) 2003-2005 Martin Quinson. All rights reserved. */ +/* Copyright (c) 2005, 2006, 2007, 2008, 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. */ @@ -15,148 +14,226 @@ #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_CATEGORY(gras_msg); -XBT_LOG_DEFAULT_CATEGORY(gras_msg); - -typedef void* gras_trp_bufdata_; - -void gras_msg_send_ext(gras_socket_t sock, - e_gras_msg_kind_t kind, - unsigned long int ID, - gras_msgtype_t msgtype, - void *payload) { - - smx_action_t act; /* simix action */ - gras_trp_sg_sock_data_t *sock_data; - gras_hostdata_t *hd; - gras_trp_procdata_t trp_remote_proc; - gras_msg_procdata_t msg_remote_proc; - gras_msg_t msg; /* message to send */ - int whole_payload_size=0; /* msg->payload_size is used to memcpy the payload. - This is used to report the load onto the simulator. It also counts the size of pointed stuff */ - - sock_data = (gras_trp_sg_sock_data_t *)sock->data; - - hd = (gras_hostdata_t *)SIMIX_host_get_data(SIMIX_host_self()); - - xbt_assert1(!gras_socket_is_meas(sock), - "Asked to send a message on the measurement socket %p", sock); - - /* got the mutex my port */ - DEBUG1("Sock port %d",sock->port); - SIMIX_mutex_lock(sock_data->mutex); - - /*initialize gras message */ - msg = xbt_new(s_gras_msg_t,1); - msg->expe = sock; - msg->kind = kind; - msg->type = msgtype; - msg->ID = ID; +#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" + +/* 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. + * Sorry, Mt. + */ +typedef struct { + xbt_thread_t listener; +} *fake_gras_msg_listener_t; +typedef struct { + smx_process_t s_process; +} *fake_xbt_thread_t; + +int gras_socket_im_the_server(gras_socket_t sock) { + gras_trp_sg_sock_data_t sock_data = sock->data; + gras_procdata_t* pd; + gras_msg_listener_t l; + xbt_thread_t listener_thread; + smx_process_t server_listener_process=NULL; + smx_process_t client_listener_process = NULL; + + + if (sock_data->server == SIMIX_process_self()) + return 1; + if (sock_data->client == SIMIX_process_self()) + return 0; + + /* neither the client nor the server. Check their respective listeners */ + pd = ((gras_procdata_t*)SIMIX_process_get_data(sock_data->server)); + l = pd->listener; + if (l) { + 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()) + return 1; + } + + if (sock_data->client) { + pd = ((gras_procdata_t*)SIMIX_process_get_data(sock_data->client)); + l = pd->listener; + if (l) { + 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()) + return 0; + } + } + /* THAT'S BAD! I should be either client or server of the sockets I get messages on!! */ + /* This is where the bug is visible. Try to die as loudly as possible */ + xbt_backtrace_display_current(); + ((char*)sock)[sizeof(*sock)+1] = '0'; /* Try to make valgrind angry to see where that damn socket comes from */ + 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", + 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", + 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()); + xbt_die("Bailing out after finding that damn bug"); + +} + +gras_msg_t gras_msg_recv_any(void) +{ + gras_trp_procdata_t trp_proc = + (gras_trp_procdata_t) gras_libdata_by_name("gras_trp"); + gras_msg_t msg; + /* Build a dynar of all communications I could get something from */ + xbt_dynar_t comms = xbt_dynar_new(sizeof(smx_comm_t), NULL); + unsigned int cursor = 0; + int got = 0; + smx_comm_t comm = NULL; + gras_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 + ("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)? + sock_data->rdv_server : sock_data->rdv_client, + gras_socket_im_the_server(sock)? + sock_data->rdv_client : sock_data->rdv_server, + sock_data->comm_recv); + + + /* If the following assert fails in some valid conditions, we need to + * change the code downward looking for the socket again. + * + * For now it relies on the facts (A) that sockets and comms are aligned + * (B) every sockets has a posted irecv in comms + * + * This is not trivial because we need that alignment to hold after the waitany(), so + * after other processes get scheduled. + * + * I cannot think of conditions where they get desynchronized (A violated) as long as + * 1) only the listener calls that function + * 2) Nobody but the listener removes sockets from that set (in main listener loop) + * 3) New sockets are added at the end, and signified ASAP to the listener (by awaking him) + * The throw bellow ensures that B is never violated without failing out loudly. + * + * We cannot search by comparing the comm object pointer that object got + * freed by the waiting process (down in smx_network, in + * comm_wait_for_completion or comm_cleanup). So, actually, we could + * use that pointer since that's a dangling pointer, but no one changes it. + * I still feel unconfortable with using dangling pointers, even if that would + * let the code work even if A and/or B are violated, provided that + * (C) the new irecv is never posted before we return from waitany to that function. + * + * Another approach, robust to B violation would be to retraverse the socks dynar with + * 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, + "Comm_recv of socket %p is empty; please report that nasty bug", + sock); + /* End of paranoia */ + + VERB4("Consider receiving messages from on comm_recv %p (%s) rdv:%p (other rdv:%p)", + sock_data->comm_recv, sock_data->comm_recv->type == comm_send? "send":"recv", + gras_socket_im_the_server(sock)? + sock_data->rdv_server : sock_data->rdv_client, + gras_socket_im_the_server(sock)? + 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)); + /* Wait for the end of any of these communications */ + got = SIMIX_network_waitany(comms); + + /* retrieve the message sent in that communication */ + xbt_dynar_get_cpy(comms, got, &(comm)); + msg = SIMIX_communication_get_data(comm); + sock = xbt_dynar_get_as(trp_proc->sockets, got, gras_socket_t); + sock_data = (gras_trp_sg_sock_data_t) sock->data; + VERB3("Got something. Communication %p's over rdv_server=%p, rdv_client=%p", + comm,sock_data->rdv_server,sock_data->rdv_client); + SIMIX_communication_destroy(comm); + + /* Reinstall a waiting communication on that rdv */ +/* xbt_dynar_foreach(trp_proc->sockets,cursor,sock) { + sock_data = (gras_trp_sg_sock_data_t) sock->data; + if (sock_data->comm_recv && sock_data->comm_recv == comm) + break; + } + */ + sock_data->comm_recv = + SIMIX_network_irecv(gras_socket_im_the_server(sock) ? + sock_data->rdv_server : sock_data->rdv_client, + NULL, 0); + + return msg; +} + + +void gras_msg_send_ext(gras_socket_t sock, + e_gras_msg_kind_t kind, + unsigned long int ID, + gras_msgtype_t msgtype, void *payload) +{ + int whole_payload_size = 0; /* msg->payload_size is used to memcpy the payload. + This is used to report the load onto the simulator. It also counts the size of pointed stuff */ + gras_msg_t msg; /* message to send */ + smx_comm_t comm; + gras_trp_sg_sock_data_t sock_data = (gras_trp_sg_sock_data_t) sock->data; + + smx_rdv_t target_rdv = + (sock_data->server == SIMIX_process_self())? + sock_data->rdv_client : + sock_data->rdv_server; + + /*initialize gras message */ + msg = xbt_new(s_gras_msg_t, 1); + sock->refcount++; + msg->expe = sock; + msg->kind = kind; + msg->type = msgtype; + msg->ID = ID; + + VERB4("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, carfull, payload is an exception */ - msg->payl_size=gras_datadesc_size(gras_datadesc_by_name("ex_t")); - msg->payl=xbt_malloc(msg->payl_size); - whole_payload_size = gras_datadesc_copy(gras_datadesc_by_name("ex_t"), - payload,msg->payl); + /* error on remote host, careful, payload is an exception */ + msg->payl_size = gras_datadesc_size(gras_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, + msg->payl); } else if (kind == e_gras_msg_kind_rpcanswer) { - msg->payl_size=gras_datadesc_size(msgtype->answer_type); - msg->payl=xbt_malloc(msg->payl_size); + msg->payl_size = gras_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_copy(msgtype->answer_type, - payload, msg->payl); + whole_payload_size = gras_datadesc_memcpy(msgtype->answer_type, + payload, msg->payl); } else { - msg->payl_size=gras_datadesc_size(msgtype->ctn_type); - msg->payl=msg->payl_size?xbt_malloc(msg->payl_size):NULL; + msg->payl_size = gras_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_copy(msgtype->ctn_type, - payload, msg->payl); + whole_payload_size = gras_datadesc_memcpy(msgtype->ctn_type, + payload, msg->payl); } - /* put message on msg_queue */ - msg_remote_proc = (gras_msg_procdata_t) - gras_libdata_by_name_from_remote("gras_msg",sock_data->to_process); - xbt_fifo_push(msg_remote_proc->msg_to_receive_queue,msg); - - /* wake-up the receiver */ - trp_remote_proc = (gras_trp_procdata_t) - gras_libdata_by_name_from_remote("gras_trp",sock_data->to_process); - - xbt_fifo_push(trp_remote_proc->msg_selectable_sockets,sock); - SIMIX_cond_signal(trp_remote_proc->msg_select_cond); - - /* wait for the receiver */ - SIMIX_cond_wait(sock_data->cond, sock_data->mutex); - - /* creates simix action and waits its ends, waits in the sender host - condition*/ - act = SIMIX_action_communicate(SIMIX_host_self(), - sock_data->to_host,msgtype->name, - (double)whole_payload_size, -1); - SIMIX_register_action_to_condition(act,sock_data->cond); - SIMIX_register_condition_to_action(act,sock_data->cond); - - VERB5("Sending to %s(%s) a message type '%s' kind '%s' ID %lu", - SIMIX_host_get_name(sock_data->to_host), - SIMIX_process_get_name(sock_data->to_process), - msg->type->name,e_gras_msg_kind_names[msg->kind], msg->ID); - - SIMIX_cond_wait(sock_data->cond, sock_data->mutex); - /* error treatmeant (FIXME)*/ - - /* cleanup structures */ - SIMIX_action_destroy(act); - SIMIX_mutex_unlock(sock_data->mutex); - - VERB0("Message sent"); -} -/* - * receive the next message on the given socket. - */ -void -gras_msg_recv(gras_socket_t sock, - gras_msg_t msg) { - - gras_trp_sg_sock_data_t *sock_data; - gras_trp_sg_sock_data_t *remote_sock_data; - gras_hostdata_t *remote_hd; - gras_msg_t msg_got; - gras_msg_procdata_t msg_procdata = - (gras_msg_procdata_t)gras_libdata_by_name("gras_msg"); - - xbt_assert1(!gras_socket_is_meas(sock), - "Asked to receive a message on the measurement socket %p", sock); - - xbt_assert0(msg,"msg is an out parameter of gras_msg_recv..."); - - sock_data = (gras_trp_sg_sock_data_t *)sock->data; - remote_sock_data = ((gras_trp_sg_sock_data_t *)sock->data)->to_socket->data; - DEBUG3("Remote host %s, Remote Port: %d Local port %d", - SIMIX_host_get_name(sock_data->to_host), sock->peer_port, sock->port); - remote_hd = (gras_hostdata_t *)SIMIX_host_get_data(sock_data->to_host); - - if (xbt_fifo_size(msg_procdata->msg_to_receive_queue) == 0 ) { - THROW_IMPOSSIBLE; - } - DEBUG1("Size msg_to_receive buffer: %d", - xbt_fifo_size(msg_procdata->msg_to_receive_queue)); - msg_got = xbt_fifo_shift(msg_procdata->msg_to_receive_queue); - - SIMIX_mutex_lock(remote_sock_data->mutex); - /* ok, I'm here, you can continuate the communication */ - SIMIX_cond_signal(remote_sock_data->cond); - - /* wait for communication end */ - SIMIX_cond_wait(remote_sock_data->cond,remote_sock_data->mutex); - - msg_got->expe= msg->expe; - memcpy(msg,msg_got,sizeof(s_gras_msg_t)); - xbt_free(msg_got); - SIMIX_mutex_unlock(remote_sock_data->mutex); - - VERB3("Received a message type '%s' kind '%s' ID %lu",// from %s", - msg->type->name, - e_gras_msg_kind_names[msg->kind], - msg->ID); + SIMIX_network_send(target_rdv, whole_payload_size, -1, -1, &msg, + sizeof(void *), &comm, msg); + + VERB0("Message sent (and received)"); + }