gpointer system_malloc(gsize size) {
Node* node = _system_switchInShadowContext();
gpointer ptr = malloc(size);
tracker_addAllocatedBytes(node_getTracker(node), ptr, size);
_system_switchOutShadowContext(node);
return ptr;
}
static void _networkinterface_scheduleNextReceive(NetworkInterface* interface) {
/* the next packets need to be received and processed */
SimulationTime batchTime = worker_getConfig()->interfaceBatchTime;
/* receive packets in batches */
while(!g_queue_is_empty(interface->inBuffer) &&
interface->receiveNanosecondsConsumed <= batchTime) {
/* get the next packet */
Packet* packet = g_queue_pop_head(interface->inBuffer);
g_assert(packet);
/* free up buffer space */
guint length = packet_getPayloadLength(packet) + packet_getHeaderSize(packet);
interface->inBufferLength -= length;
/* hand it off to the correct socket layer */
gint key = packet_getDestinationAssociationKey(packet);
Socket* socket = g_hash_table_lookup(interface->boundSockets, GINT_TO_POINTER(key));
gchar* packetString = packet_getString(packet);
debug("packet in: %s", packetString);
g_free(packetString);
_networkinterface_pcapWritePacket(interface, packet);
/* if the socket closed, just drop the packet */
gint socketHandle = -1;
if(socket) {
socketHandle = *descriptor_getHandleReference((Descriptor*)socket);
gboolean needsRetransmit = socket_pushInPacket(socket, packet);
if(needsRetransmit) {
/* socket can not handle it now, so drop it */
_networkinterface_dropInboundPacket(interface, packet);
}
}
/* successfully received, calculate how long it took to 'receive' this packet */
interface->receiveNanosecondsConsumed += (length * interface->timePerByteDown);
tracker_addInputBytes(node_getTracker(worker_getPrivate()->cached_node),(guint64)length, socketHandle);
}
/*
* we need to call back and try to receive more, even if we didnt consume all
* of our batch time, because we might have more packets to receive then.
*/
SimulationTime receiveTime = (SimulationTime) floor(interface->receiveNanosecondsConsumed);
if(receiveTime >= SIMTIME_ONE_NANOSECOND) {
/* we are 'receiving' the packets */
interface->flags |= NIF_RECEIVING;
/* call back when the packets are 'received' */
InterfaceReceivedEvent* event = interfacereceived_new(interface);
/* event destination is our node */
worker_scheduleEvent((Event*)event, receiveTime, 0);
}
}
/*
* this function builds a UDP packet and sends to the virtual node given by the
* ip and port parameters. this function assumes that the socket is already
* bound to a local port, no matter if that happened explicitly or implicitly.
*/
gssize udp_sendUserData(UDP* udp, gconstpointer buffer, gsize nBytes, in_addr_t ip, in_port_t port) {
MAGIC_ASSERT(udp);
gsize space = socket_getOutputBufferSpace(&(udp->super));
if(space < nBytes) {
/* not enough space to buffer the data */
return -1;
}
/* break data into segments and send each in a packet */
gsize maxPacketLength = CONFIG_DATAGRAM_MAX_SIZE;
gsize remaining = nBytes;
gsize offset = 0;
/* create as many packets as needed */
while(remaining > 0) {
gsize copyLength = MIN(maxPacketLength, remaining);
/* use default destination if none was specified */
in_addr_t destinationIP = (ip != 0) ? ip : udp->super.peerIP;
in_port_t destinationPort = (port != 0) ? port : udp->super.peerPort;
/* create the UDP packet */
Packet* packet = packet_new(buffer + offset, copyLength);
packet_setUDP(packet, PUDP_NONE, socket_getBinding(&(udp->super)),
udp->super.boundPort, destinationIP, destinationPort);
/* buffer it in the transport layer, to be sent out when possible */
gboolean success = socket_addToOutputBuffer((Socket*) udp, packet);
/* counter maintenance */
if(success) {
remaining -= copyLength;
offset += copyLength;
} else {
warning("unable to send UDP packet");
break;
}
}
/* update the tracker output buffer stats */
Tracker* tracker = node_getTracker(worker_getPrivate()->cached_node);
Socket* socket = (Socket* )udp;
Descriptor* descriptor = (Descriptor *)socket;
gsize outLength = socket_getOutputBufferLength(socket);
gsize outSize = socket_getOutputBufferSize(socket);
tracker_updateSocketOutputBuffer(tracker, descriptor->handle, outLength, outSize);
debug("buffered %"G_GSIZE_FORMAT" outbound UDP bytes from user", offset);
return (gssize) offset;
}
gssize udp_receiveUserData(UDP* udp, gpointer buffer, gsize nBytes, in_addr_t* ip, in_port_t* port) {
MAGIC_ASSERT(udp);
Packet* packet = socket_removeFromInputBuffer((Socket*)udp);
if(!packet) {
return -1;
}
/* copy lesser of requested and available amount to application buffer */
guint packetLength = packet_getPayloadLength(packet);
gsize copyLength = MIN(nBytes, packetLength);
guint bytesCopied = packet_copyPayload(packet, 0, buffer, copyLength);
g_assert(bytesCopied == copyLength);
/* fill in address info */
if(ip) {
*ip = packet_getSourceIP(packet);
}
if(port) {
*port = packet_getSourcePort(packet);
}
/* destroy packet, throwing away any bytes not claimed by the app */
packet_unref(packet);
/* update the tracker output buffer stats */
Tracker* tracker = node_getTracker(worker_getPrivate()->cached_node);
Socket* socket = (Socket* )udp;
Descriptor* descriptor = (Descriptor *)socket;
gsize outLength = socket_getOutputBufferLength(socket);
gsize outSize = socket_getOutputBufferSize(socket);
tracker_updateSocketOutputBuffer(tracker, descriptor->handle, outLength, outSize);
debug("user read %u inbound UDP bytes", bytesCopied);
return (gssize)bytesCopied;
}
void system_free(gpointer ptr) {
Node* node = _system_switchInShadowContext();
free(ptr);
tracker_removeAllocatedBytes(node_getTracker(node), ptr);
_system_switchOutShadowContext(node);
}
static void _networkinterface_scheduleNextSend(NetworkInterface* interface) {
/* the next packet needs to be sent according to bandwidth limitations.
* we need to spend time sending it before sending the next. */
SimulationTime batchTime = worker_getConfig()->interfaceBatchTime;
/* loop until we find a socket that has something to send */
while(interface->sendNanosecondsConsumed <= batchTime) {
gint socketHandle = -1;
/* choose which packet to send next based on our queuing discipline */
Packet* packet;
switch(interface->qdisc) {
case NIQ_RR: {
packet = _networkinterface_selectRoundRobin(interface, &socketHandle);
break;
}
case NIQ_FIFO:
default: {
packet = _networkinterface_selectFirstInFirstOut(interface, &socketHandle);
break;
}
}
if(!packet) {
break;
}
/* now actually send the packet somewhere */
if(networkinterface_getIPAddress(interface) == packet_getDestinationIP(packet)) {
/* packet will arrive on our own interface */
PacketArrivedEvent* event = packetarrived_new(packet);
/* event destination is our node */
worker_scheduleEvent((Event*)event, 1, 0);
} else {
/* let the network schedule with appropriate delays */
network_schedulePacket(interface->network, packet);
}
gchar* packetString = packet_getString(packet);
debug("packet out: %s", packetString);
g_free(packetString);
/* successfully sent, calculate how long it took to 'send' this packet */
guint length = packet_getPayloadLength(packet) + packet_getHeaderSize(packet);
interface->sendNanosecondsConsumed += (length * interface->timePerByteUp);
tracker_addOutputBytes(node_getTracker(worker_getPrivate()->cached_node),(guint64)length, socketHandle);
_networkinterface_pcapWritePacket(interface, packet);
}
/*
* we need to call back and try to send more, even if we didnt consume all
* of our batch time, because we might have more packets to send then.
*/
SimulationTime sendTime = (SimulationTime) floor(interface->sendNanosecondsConsumed);
if(sendTime >= SIMTIME_ONE_NANOSECOND) {
/* we are 'sending' the packets */
interface->flags |= NIF_SENDING;
/* call back when the packets are 'sent' */
InterfaceSentEvent* event = interfacesent_new(interface);
/* event destination is our node */
worker_scheduleEvent((Event*)event, sendTime, 0);
}
}
