NetBridge.cpp

Go to the documentation of this file.

/******************************************************************************
 * This file is part of project ORCA. More information on the project
 * can be found at the following repositories at GitHub's website.
 *
 * http://https://github.com/andersondomingues/orca-sim
 * http://https://github.com/andersondomingues/orca-software
 * http://https://github.com/andersondomingues/orca-mpsoc
 * http://https://github.com/andersondomingues/orca-tools
 *
 * Copyright (C) 2018-2020 Anderson Domingues, <ti.andersondomingues@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 
******************************************************************************/

#include <stdio.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

// std API
#include <iostream>
#include <sstream>
#include <chrono>
#include <string>

// simulator API
#include "TimedModel.hpp"
#include "Buffer.hpp"

#include "NetBridge.hpp"

using orcasim::models::orca::NetBridge;
using orcasim::models::orca::NetBridgeRecvState;
using orcasim::models::orca::NetBridgeSendState;
using orcasim::models::orca::FlitType;

using orcasim::models::orca::udp_client;
using orcasim::models::orca::udp_server;
using orcasim::models::orca::udp_client_server_runtime_error;

NetBridge::NetBridge(std::string name) : TimedModel(name) {
    // open debug file
    output_debug.open("logs/000.net_debug.log",
        std::ofstream::out | std::ofstream::trunc);
    output_uart.open("logs/000.net_uart.log",
        std::ofstream::out | std::ofstream::trunc);

    // create a new signal so that the module can be interrupted by
    // the external network when a new packet arrives
    _signal_recv = new Signal<int8_t>(&_recv_val, 0,
        this->GetName() + ".signalUdpIntr");
    _signal_recv->Write(0);

    #ifdef NETBRIDGE_ENABLE_LOG_INPUT
    _trafficIn = 0;
    #endif

    #ifdef NETBRIDGE_ENABLE_LOG_OUTPUT
    _trafficOut = 0;
    #endif

    // initialize states
    _recv_state = NetBridgeRecvState::READY;
    _send_state = NetBridgeSendState::READY;

    // initialize a new client (client sends messages)
    const std::string& client_addr = NETSOCKET_CLIENT_ADDRESS;
    _udp_client = new udp_client(client_addr, NETSOCKET_CLIENT_PORT);

    const std::string& server_addr = NETSOCKET_SERVER_ADDRESS;
    _udp_server = new udp_server(server_addr, NETSOCKET_SERVER_PORT);

    // this code depends on linux's libraries. I warned you.
    output_uart
        << "Virtual Ethernet Adapter is up." << std::endl
        << "Server ip:" << NETSOCKET_SERVER_ADDRESS << ":"
        << NETSOCKET_SERVER_PORT << std::endl
        << "Client ip:" << NETSOCKET_CLIENT_ADDRESS << ":"
        << NETSOCKET_CLIENT_PORT << std::endl;

    // instantiate a new input buffer (only input is buferred)
    _ib = new Buffer<FlitType>(this->GetName() + ".buffer.in",
        HWBUFFER_LEN);

    this->Reset();

    udpRecvThread_terminate = 0;
    if (pthread_create(&_t, NULL, NetBridge::udpRecvThread, this)) {
        std::cout << "unable to create new thread using lpthread."
            << std:: endl;
    }
}

Signal<int8_t>* NetBridge::GetSignalRecv() {
    return _signal_recv;
}

uint8_t* NetBridge::GetBuffer() {
    return _recv_buffer;
}

NetBridge::~NetBridge() {
    delete(_ib);
    delete(_signal_recv);

    delete(_udp_client);
    delete(_udp_server);

    udpRecvThread_terminate = 1;

    output_debug.close();
    output_uart.close();
}

void NetBridge::Reset() {
    // TODO(ad): missing reset method
}

Buffer<FlitType>* NetBridge::GetInputBuffer() {
    return _ib;
}

void NetBridge::SetOutputBuffer(Buffer<FlitType>* b) {
    _ob = b;
}

udp_server* NetBridge::GetUdpServer() {
    return _udp_server;
}

SimulationTime NetBridge::Run() {
    // std::cout << this->GetName() << std::endl;
    this->udpToNocProcess();  // process for receiving from the UDP socket
    this->nocToUdpProcess();  // process for sending through the UDP socket
    return 1;  // takes exactly 1 cycle to run both processes
}

void* NetBridge::udpRecvThread(void* gs) {
    NetBridge* ns = reinterpret_cast<NetBridge*>(gs);

    // recv while the program lives
    while (!(ns->udpRecvThread_terminate)) {
        // recv only when interface is not busy
        if (ns->GetSignalRecv()->Read() == 0x0) {
            // TODO(ad): switch to udp polling
            // recvs from external network
            ns->GetUdpServer()->recv(
                reinterpret_cast<char*>(ns->GetBuffer()), RECV_BUFFER_LEN);

            // start interface
            ns->GetSignalRecv()->Write(0x1);
        }
    }
    return 0;
}

void NetBridge::LogWrite(std::string ss) {
    this->output_debug << ss << std::flush;
}

void NetBridge::udpToNocProcess() {
    // Receive a packet from the network and send data flit-by-flit
    // to the noc. NoC buffers have unlimited size, although we can
    // check on buffers' size if necessary.
    // TODO(ad): to model network congestion.
    switch (_recv_state) {
        // READY: In this state, the module is waiting for an UDP packet. There
        // is a separated process that receives the packet and writes it to the
        //  internal buffer, so we just wait for the control signal to raise.
        case NetBridgeRecvState::READY: {
            // packet has arrived and the network is not sending packets
            if (_signal_recv->Read() == 0x1 && !_ob->full()) {
                // push the first flit to the NoC, whatever the content.
                FlitType* buf = reinterpret_cast<FlitType*>(_recv_buffer);
                _out_reg = buf[0];
                _ob->push(_out_reg);

                // proceed to the next state
                _recv_state = NetBridgeRecvState::READ_LEN;

                #ifdef NETBRIDGE_ENABLE_LOG_INPUT
                int32_t x = (_out_reg & 0xf0) >> 4;
                int32_t y = (_out_reg & 0x0f);
                int32_t z = x + y * 4;

                std::chrono::time_point<std::chrono::system_clock> now;
                now = std::chrono::system_clock::now();

                auto duration = now.time_since_epoch();
                auto millis =
                    std::chrono::duration_cast<std::chrono::milliseconds>(
                        duration).count();

                output_debug << "[" << millis << "] IN " << _trafficIn
                             << " FROM " << _udp_server->get_addr() << ":"
                             << _udp_server->get_port()
                             << " TO #" << z << std::endl << std::flush;

                _trafficIn++;
                #endif
            }
        } break;

        // READ_LEN: In this state we read the second flit, which carries the
        // size of the burst. We determine how many cycle we spend bursting data
        // out of the module in this state.
        case NetBridgeRecvState::READ_LEN: {
            if (!_ob->full()) {
                FlitType* buf = reinterpret_cast<FlitType*>(_recv_buffer);
                _out_reg = buf[1];
                _ob->push(_out_reg);

                // there is no condition to trigger this state as the data
                // is already stored to the memory. we increment the number
                // of flits in two given that neither address and size flits
                // are accounted.
                _flits_to_recv = _out_reg + 2;
                _flits_to_recv_count = 2;

                // proceed to next state
                _recv_state = NetBridgeRecvState::RECV_PAYLOAD;
            }
        } break;

        // RECV_PAYLOAD: We stay in this state until we send all the remaining
        // flits to the noc.
        case NetBridgeRecvState::RECV_PAYLOAD: {
            // no more flits to recv, go back to the first state
            if (_flits_to_recv_count >= _flits_to_recv) {
                _signal_recv->Write(0x0);
                _recv_state = NetBridgeRecvState::READY;

            // still have flits to send
            } else if (!_ob->full()) {
                _out_reg = (reinterpret_cast<FlitType*>(_recv_buffer))
                    [_flits_to_recv_count++];
                _ob->push(_out_reg);
            }
        } break;
    }
}

void NetBridge::nocToUdpProcess() {
    switch (_send_state) {
        // READY: In this state we wait for the first flit to come from the noc
        case NetBridgeSendState::READY: {
            // fall whether we have any flit coming from the noc
            if (_ib->size() > 0) {
                // put address flit into the send buffer
                FlitType* buf = reinterpret_cast<FlitType*>(_send_buffer);
                buf[0] = _ib->top();
                _ib->pop();

                #ifdef NETBRIDGE_ENABLE_LOG_OUTPUT
                uint32_t x = buf[4];

                std::chrono::time_point<std::chrono::system_clock> now =
                    std::chrono::system_clock::now();
                auto duration = now.time_since_epoch();
                auto millis =
                    std::chrono::duration_cast<std::chrono::milliseconds>(
                        duration).count();

                output_debug << "[" << millis << "] OUT " << _trafficOut
                             << " TO " << _udp_client->get_addr() << ":"
                             << _udp_client->get_port()
                             << " FROM #" << x << std::endl << std::flush;
                #endif

                // change states
                _send_state = NetBridgeSendState::SEND_LEN;
            }
        } break;

        // SEND_LEN: In this state we read how many flits we must receive from
        // the noc until we send the next network packet.
        case NetBridgeSendState::SEND_LEN: {
            if (_ib->size() > 0) {
                // put address flit into the send buffer
                FlitType* buf = reinterpret_cast<FlitType*>(_send_buffer);
                buf[1] = _ib->top();

                _flits_to_send = _ib->top() + 2;

                // starts in two due to we have added address and size flits
                _flits_to_send_count = 2;
                _ib->pop();

                // change states
                _send_state = NetBridgeSendState::SEND_PAYLOAD;
            }
        } break;

        // SEND_PAYLOAD: Send store data and go back to the first state
        case NetBridgeSendState::SEND_PAYLOAD: {
            // still have flits to receive from the noc
            if (_flits_to_send_count < _flits_to_send) {
                if (_ib->size() > 0) {
                    FlitType* buf = reinterpret_cast<FlitType*>(_send_buffer);
                    buf[_flits_to_send_count] = _ib->top();
                    _ib->pop();

                    _flits_to_send_count++;
                }
            } else {
                // send message through the udp socket
                _udp_client->send((const char*)_send_buffer, SEND_BUFFER_LEN);

                // go back to the first state
                _send_state = NetBridgeSendState::READY;
            }
        }
    }
}

// ---------------------- UDP stuff
// reference: https://linux.m2osw.com/c-implementation-udp-clientserver


// ========================= CLIENT =========================

udp_client::udp_client(const std::string& addr, int port)
    : f_port(port)
    , f_addr(addr) {
    char decimal_port[16];
    snprintf(decimal_port, sizeof(decimal_port), "%d", f_port);
    decimal_port[sizeof(decimal_port) / sizeof(decimal_port[0]) - 1] = '\0';
    struct addrinfo hints;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_protocol = IPPROTO_UDP;
    int r(getaddrinfo(addr.c_str(), decimal_port, &hints, &f_addrinfo));
    if (r != 0 || f_addrinfo == NULL) {
        throw udp_client_server_runtime_error(("invalid address or port: \""
            + addr + ":" + decimal_port + "\"").c_str());
    }

    f_socket = socket(f_addrinfo->ai_family, SOCK_DGRAM |
        SOCK_CLOEXEC, IPPROTO_UDP);

    if (f_socket == -1) {
        freeaddrinfo(f_addrinfo);
        throw udp_client_server_runtime_error(("could not create socket for: \""
            + addr + ":" + decimal_port + "\"").c_str());
    }
}

udp_client::~udp_client() {
    freeaddrinfo(f_addrinfo);
    close(f_socket);
}

int udp_client::get_socket() const {
    return f_socket;
}

int udp_client::get_port() const {
    return f_port;
}

std::string udp_client::get_addr() const {
    return f_addr;
}

int udp_client::send(const char *msg, size_t size) {
    return sendto(f_socket, msg, size, 0, f_addrinfo->ai_addr,
        f_addrinfo->ai_addrlen);
}

// ========================= SEVER =========================
udp_server::udp_server(const std::string& addr, int port)
    : f_port(port)
    , f_addr(addr) {
    char decimal_port[16];
    snprintf(decimal_port, sizeof(decimal_port), "%d", f_port);
    decimal_port[sizeof(decimal_port) / sizeof(decimal_port[0]) - 1] = '\0';
    struct addrinfo hints;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_protocol = IPPROTO_UDP;
    int r(getaddrinfo(addr.c_str(), decimal_port, &hints, &f_addrinfo));

    if (r != 0 || f_addrinfo == NULL) {
        throw udp_client_server_runtime_error(
            ("invalid address or port for UDP socket: \"" + addr + ":"
                + decimal_port + "\"").c_str());
    }

    f_socket = socket(f_addrinfo->ai_family, SOCK_DGRAM |
        SOCK_CLOEXEC, IPPROTO_UDP);

    if (f_socket == -1) {
        freeaddrinfo(f_addrinfo);
        throw udp_client_server_runtime_error(
            ("could not create UDP socket for: \"" + addr + ":" + decimal_port
                + "\"").c_str());
    }
    r = bind(f_socket, f_addrinfo->ai_addr, f_addrinfo->ai_addrlen);
    if (r != 0) {
        freeaddrinfo(f_addrinfo);
        close(f_socket);
        throw udp_client_server_runtime_error(
            ("could not bind UDP socket with: \"" + addr + ":" + decimal_port
                + "\"").c_str());
    }
}

udp_server::~udp_server() {
    freeaddrinfo(f_addrinfo);
    close(f_socket);
}

int udp_server::get_socket() const {
    return f_socket;
}

int udp_server::get_port() const {
    return f_port;
}

std::string udp_server::get_addr() const {
    return f_addr;
}

int udp_server::recv(char *msg, size_t max_size) {
    return ::recv(f_socket, msg, max_size, 0);
}

int udp_server::timed_recv(char *msg, size_t max_size, int max_wait_ms) {
    fd_set s;
    FD_ZERO(&s);
    FD_SET(f_socket, &s);
    struct timeval timeout;
    timeout.tv_sec = max_wait_ms / 1000;
    timeout.tv_usec = (max_wait_ms % 1000) * 1000;

    int retval = select(f_socket + 1, &s, 0, 0, &timeout);
    if (retval == -1) {
        // select() set errno accordingly
        return -1;
    }

    if (retval > 0) {
        // our socket has data
        return ::recv(f_socket, msg, max_size, 0);
    }

    // our socket has no data
    errno = EAGAIN;
    return -1;
}