X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/49e85177c669d793e84242983a1b1f430e47184e..6c930c685c64eb5bcf2e73ba17bbeddc8fe19a74:/src/surf/ns3/ns3_simulator.cc diff --git a/src/surf/ns3/ns3_simulator.cc b/src/surf/ns3/ns3_simulator.cc index 4ad133eed5..e675094a85 100644 --- a/src/surf/ns3/ns3_simulator.cc +++ b/src/surf/ns3/ns3_simulator.cc @@ -1,215 +1,133 @@ -/* Copyright (c) 2007-2014. The SimGrid Team. - * All rights reserved. */ +/* Copyright (c) 2007-2017. 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. */ -#include "surf/ns3/ns3_simulator.h" +#include "src/surf/ns3/ns3_simulator.h" #include "xbt/dict.h" #include "xbt/log.h" #include "xbt/sysdep.h" -using namespace ns3; -using namespace std; +#include -xbt_dict_t dict_socket = NULL; +xbt_dict_t flowFromSock = xbt_dict_new_homogeneous([](void *p) { + delete (SgFlow*)p; +}); // ns3::sock -> SgFlow -NS3Sim SimulatorNS3; -static char socket_key[24]; +static void receive_callback(ns3::Ptr socket); +static void datasent_callback(ns3::Ptr socket, uint32_t dataSent); -static void receive_callback(Ptr localSocket); -static void send_callback(Ptr localSocket, uint32_t txSpace); -static void datasent_callback(Ptr localSocket, uint32_t dataSent); -static void StartFlow(Ptr sock, - const char *to, - uint16_t port_number); +XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(ns3); -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simulator_ns3, surf, - "Logging specific to the SURF network NS3 module"); - -// Constructor. -NS3Sim::NS3Sim(){ -} -//Destructor. -NS3Sim::~NS3Sim(){ -} - -static XBT_INLINE void transformSocketPtr (Ptr localSocket){ - std::stringstream sstream; - sstream << localSocket ; - std::string s = sstream.str(); - sprintf(socket_key,"%s",s.c_str()); -} - -static void delete_mysocket(void *p) +SgFlow::SgFlow(uint32_t totalBytes, simgrid::surf::NetworkNS3Action* action) { - MySocket *sock = (MySocket *)p; - delete(sock); + totalBytes_ = totalBytes; + remaining_ = totalBytes; + action_ = action; } -/* - * This function create a flow from src to dst - * - * Parameters - * src: node source - * dst: node destination - * port_number: The port number to use - * start: the time the communication start - * addr: ip address - * totalBytes: number of bytes to transmit - */ -void NS3Sim::create_flow_NS3( - Ptr src, - Ptr dst, - uint16_t port_number, - double start, - const char *addr, - uint32_t totalBytes, - void * action) +static SgFlow* getFlowFromSocket(ns3::Ptr socket) { - if(!dict_socket) dict_socket = xbt_dict_new_homogeneous(delete_mysocket); - - PacketSinkHelper sink ("ns3::TcpSocketFactory", - InetSocketAddress (Ipv4Address::GetAny(), - port_number)); - sink.Install (dst); - - Ptr sock = Socket::CreateSocket (src, - TcpSocketFactory::GetTypeId()); - - MySocket *mysocket = new MySocket(); - mysocket->totalBytes = totalBytes; - mysocket->remaining = totalBytes; - mysocket->bufferedBytes = 0; - mysocket->sentBytes = 0; - mysocket->finished = 0; - mysocket->action = action; - - transformSocketPtr(sock); - xbt_dict_set(dict_socket,socket_key, mysocket,NULL); - - sock->Bind(InetSocketAddress(port_number)); - XBT_DEBUG("Create flow starting to %fs + %fs = %fs",start-ns3_time(), ns3_time(), start); - - Simulator::Schedule (Seconds(start-ns3_time()),&StartFlow, sock, addr, port_number); -// Simulator::Schedule (Seconds(0.0),&StartFlow, sock, addr, port_number); - -} - -void* NS3Sim::get_action_from_socket(void *socket){ - return ((MySocket *)socket)->action; -} - -char NS3Sim::get_finished(void *socket){ - return ((MySocket *)socket)->finished; -} - -double NS3Sim::get_remains_from_socket(void *socket){ - return ((MySocket *)socket)->remaining; -} - -double NS3Sim::get_sent_from_socket(void *socket){ - return ((MySocket *)socket)->sentBytes; -} - -void NS3Sim::simulator_start(double min){ - if(min > 0.0) - Simulator::Stop(Seconds(min)); - XBT_DEBUG("Start simulator '%f'",min); - Simulator::Run (); + return (SgFlow*)xbt_dict_get_or_null(flowFromSock, transformSocketPtr(socket)); } -static MySocket* get_my_socket(Ptr localSocket) { - transformSocketPtr(localSocket); - return (MySocket*)xbt_dict_get_or_null(dict_socket,socket_key); -} - -static void receive_callback(Ptr localSocket){ - MySocket* mysocket = get_my_socket(localSocket); - - if (mysocket->finished == 0){ - mysocket->finished = 1; - XBT_DEBUG("recv_cb of F[%p, %p, %d]", mysocket, mysocket->action, mysocket->totalBytes); - XBT_DEBUG("Stop simulator at %f seconds", Simulator::Now().GetSeconds()); - Simulator::Stop(Seconds(0.0)); - Simulator::Run(); +static void receive_callback(ns3::Ptr socket) +{ + SgFlow* flow = getFlowFromSocket(socket); + + if (flow->finished_ == false) { + flow->finished_ = true; + XBT_DEBUG("recv_cb of F[%p, %p, %u]", flow, flow->action_, flow->totalBytes_); + XBT_DEBUG("Stop simulator at %f seconds", ns3::Simulator::Now().GetSeconds()); + ns3::Simulator::Stop(ns3::Seconds(0.0)); + ns3::Simulator::Run(); } } -static void send_callback(Ptr localSocket, uint32_t txSpace){ - MySocket* mysocket = get_my_socket(localSocket); - - if (mysocket->remaining == 0){ - //all data was already buffered (and socket was already closed), just return - return; - } +static void WriteUntilBufferFull(ns3::Ptr sock, uint32_t txSpace) +{ + SgFlow* flow = getFlowFromSocket(sock); - uint8_t *data = (uint8_t*)malloc(sizeof(uint8_t)*txSpace); + if (flow->remaining_ == 0) // all data was already buffered (and socket was already closed) + return; - while (mysocket->bufferedBytes < mysocket->totalBytes - && localSocket->GetTxAvailable () > 0) - { - uint32_t toWrite = min ((mysocket->remaining), txSpace); - toWrite = min (toWrite, localSocket->GetTxAvailable ()); - int amountSent = localSocket->Send (data, toWrite, 0); + /* While not all is buffered and there remain space in the buffers */ + while (flow->bufferedBytes_ < flow->totalBytes_ && sock->GetTxAvailable() > 0) { - if(amountSent < 0) - return; - (mysocket->bufferedBytes) += amountSent; - (mysocket->remaining) -= amountSent; - XBT_DEBUG("send_cb of F[%p, %p, %d] (%d/%d) %d buffered", mysocket, mysocket->action, mysocket->totalBytes, mysocket->remaining, mysocket->totalBytes, amountSent); + uint32_t toWrite = std::min({flow->remaining_, sock->GetTxAvailable()}); + if (toWrite == 0) // buffer full + return; + int amountSent = sock->Send(0, toWrite, 0); - } + xbt_assert(amountSent > 0, "Since TxAvailable>0, amountSent should also >0"); + flow->bufferedBytes_ += amountSent; + flow->remaining_ -= amountSent; - free(data); + XBT_DEBUG("%f: sent %d bytes over flow %p (still %u to go)", ns3::Simulator::Now().GetSeconds(), amountSent, flow, + flow->remaining_); + } - if ((mysocket->bufferedBytes) >= mysocket->totalBytes){ - localSocket->Close(); - } + if (flow->bufferedBytes_ >= flow->totalBytes_) + sock->Close(); } -static void datasent_callback(Ptr localSocket, uint32_t dataSent){ - MySocket* mysocket = get_my_socket(localSocket); - mysocket->sentBytes += dataSent; - XBT_DEBUG("datasent_cb of F[%p, %p, %d] %d sent", mysocket, mysocket->action, mysocket->totalBytes, dataSent); +static void datasent_callback(ns3::Ptr socket, uint32_t dataSent) +{ + /* The tracing wants to know */ + SgFlow* flow = getFlowFromSocket(socket); + flow->sentBytes_ += dataSent; + XBT_DEBUG("datasent_cb of F[%p, %p, %u] %u sent (%u total)", flow, flow->action_, flow->totalBytes_, dataSent, + flow->sentBytes_); } -static void normalClose_callback(Ptr localSocket){ - MySocket* mysocket = get_my_socket(localSocket); - XBT_DEBUG("normalClose_cb of F[%p, %p, %d]", mysocket, mysocket->action, mysocket->totalBytes); - receive_callback (localSocket); +static void normalClose_callback(ns3::Ptr socket) +{ + SgFlow* flow = getFlowFromSocket(socket); + XBT_DEBUG("normalClose_cb of F[%p, %p, %u]", flow, flow->action_, flow->totalBytes_); + receive_callback(socket); } -static void errorClose_callback(Ptr localSocket){ - MySocket* mysocket = get_my_socket(localSocket); - XBT_DEBUG("errorClose_cb of F[%p, %p, %d]", mysocket, mysocket->action, mysocket->totalBytes); +static void errorClose_callback(ns3::Ptr socket) +{ + SgFlow* flow = getFlowFromSocket(socket); + XBT_DEBUG("errorClose_cb of F[%p, %p, %u]", flow, flow->action_, flow->totalBytes_); xbt_die("NS3: a socket was closed anormally"); } -static void succeededConnect_callback(Ptr localSocket){ - MySocket* mysocket = get_my_socket(localSocket); - XBT_DEBUG("succeededConnect_cb of F[%p, %p, %d]", mysocket, mysocket->action, mysocket->totalBytes); +static void succeededConnect_callback(ns3::Ptr socket) +{ + SgFlow* flow = getFlowFromSocket(socket); + XBT_DEBUG("succeededConnect_cb of F[%p, %p, %u]", flow, flow->action_, flow->totalBytes_); } -static void failedConnect_callback(Ptr localSocket){ - MySocket* mysocket = get_my_socket(localSocket); - XBT_DEBUG("failedConnect_cb of F[%p, %p, %d]", mysocket, mysocket->action, mysocket->totalBytes); +static void failedConnect_callback(ns3::Ptr socket) +{ + SgFlow* mysocket = getFlowFromSocket(socket); + XBT_DEBUG("failedConnect_cb of F[%p, %p, %u]", mysocket, mysocket->action_, mysocket->totalBytes_); xbt_die("NS3: a socket failed to connect"); } -static void StartFlow(Ptr sock, - const char *to, - uint16_t port_number) +void StartFlow(ns3::Ptr sock, const char* to, uint16_t port_number) { - InetSocketAddress serverAddr (to, port_number); + SgFlow* flow = getFlowFromSocket(sock); + ns3::InetSocketAddress serverAddr(to, port_number); sock->Connect(serverAddr); - sock->SetSendCallback (MakeCallback (&send_callback)); - sock->SetRecvCallback (MakeCallback (&receive_callback)); - sock->SetDataSentCallback (MakeCallback (&datasent_callback)); - sock->SetConnectCallback (MakeCallback (&succeededConnect_callback), MakeCallback (&failedConnect_callback)); - sock->SetCloseCallbacks (MakeCallback (&normalClose_callback), MakeCallback (&errorClose_callback)); - - MySocket* mysocket = get_my_socket(sock); - XBT_DEBUG("startFlow_cb of F[%p, %p, %d] dest=%s port=%d", mysocket, mysocket->action, mysocket->totalBytes, to, port_number); + // tell the tcp implementation to call WriteUntilBufferFull again + // if we blocked and new tx buffer space becomes available + sock->SetSendCallback (MakeCallback(&WriteUntilBufferFull)); + // Note when the send is over + sock->SetRecvCallback(MakeCallback(&receive_callback)); + // Keep track of what was used (for the TRACING module) + sock->SetDataSentCallback(MakeCallback(&datasent_callback)); + XBT_DEBUG("startFlow of F[%p, %p, %u] dest=%s port=%d", flow, flow->action_, flow->totalBytes_, to, port_number); + + //WriteUntilBufferFull (sock, sock->GetTxAvailable ()); + /* + sock->SetSendCallback(MakeCallback(&send_callback)); + sock->SetConnectCallback(MakeCallback(&succeededConnect_callback), MakeCallback(&failedConnect_callback)); + sock->SetCloseCallbacks(MakeCallback(&normalClose_callback), MakeCallback(&errorClose_callback)); + send_callback(sock, sock->GetTxAvailable ()); + */ + }