prrt.pyx

from libc.stdint cimport uint32_t, uint16_t, uint8_t, int32_t
from libc.stdlib cimport malloc, free
from posix.time cimport timespec
cimport cython

cimport cprrt

cdef extern from "proto/applicationConstraints.c":
    pass

cdef extern from "proto/stores/dataPacketStore.c":
    pass

cdef extern from "proto/stores/deliveredPacketTable.c":
    pass

cdef extern from "proto/stores/receptionTable.c":
    pass

cdef extern from "proto/stores/packetTimeoutTable.c":
    pass

cdef extern from "proto/stores/packetTimeoutTable.c":
    pass

cdef extern from "proto/stores/inFlightPacketStore.c":
    pass

cdef extern from "proto/stores/repairBlockStore.c":
    pass

cdef extern from "proto/stores/packetDeliveryStore.c":
    pass

cdef extern from "proto/types/packetTimeout.c":
    pass

cdef extern from "proto/types/lossStatistics.c":
    pass

cdef extern from "proto/processes/feedbackReceiver.c":
    pass

cdef extern from "proto/processes/dataReceiver.c":
    pass

cdef extern from "proto/processes/dataTransmitter.c":
    pass

cdef extern from "proto/block.c":
    pass

cdef extern from "proto/bbr.c":
    pass

cdef extern from "proto/clock.c":
    pass

cdef extern from "proto/channelStateInformation.c":
    pass

cdef extern from "proto/vdmcode/block_code.c":
    pass

cdef extern from "proto/codingParams.c":
    pass

cdef extern from "proto/receiver.c":
    pass

cdef extern from "proto/types/packet.c":
    pass

cdef extern from "proto/socket.c":
    pass

cdef extern from "util/bptree.c":
    pass

cdef extern from "util/bitmap.c":
    pass

cdef extern from "util/common.c":
    pass

cdef extern from "util/list.c":
    pass

cdef extern from "util/pipe.c":
    pass

cdef extern from "util/mpsc_queue.c":
    pass

cdef extern from "util/windowedFilter.c":
    pass

class PrrtCodingConfiguration:
    def __init__(self, n, k, n_cycle):
        # TODO: Validity checks
        # n >= k
        # sum(n_cycle) == n - k
        self.n = n
        self.k = k
        self.n_cycle = n_cycle

    def __repr__(self):
        return "PrrtCodingConfiguration(n={},k={},n_cycle={})".format(self.n, self.k, self.n_cycle)

    def __repr__(self):
        return "({},{},{})".format(self.n, self.k, self.n_cycle)

    #property n_cycle:
    #    def __get__(self):
    #        return list(<uint8_t[:self._c_config.c]> self._c_config.n_cycle)

cdef class PrrtSocket:
    cdef cprrt.PrrtSocket* _c_socket
    cdef bint isSender

    def __cinit__(self, port, isSender, target_delay = 1, thread_pinning = False):
        target_delay_us = target_delay * 1000**2
        self._c_socket = cprrt.PrrtSocket_create(isSender, target_delay_us)
        if thread_pinning:
            cprrt.PrrtSocket_enable_thread_pinning(self._c_socket)
        cprrt.PrrtSocket_bind(self._c_socket, "0.0.0.0", port)

        self.isSender = isSender

    property plr:

        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_plr(self._c_socket)

    property thread_pinning:

        def __get__(self):
            return cprrt.PrrtSocket_uses_thread_pinning(self._c_socket)

    property target_delay:

        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_sock_opt(self._c_socket, "targetdelay") * 0.000001

    property app_queue_size:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_sock_opt(self._c_socket, "app_queue_size")

        def __set__(self, value):
            if not self.isSender:
                raise Exception("Not a sender.")
            cprrt.PrrtSocket_set_sock_opt(self._c_socket, "app_queue_size", value)

    property rtt:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_rtprop(self._c_socket) * 0.000001

    property coding_configuration:

        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            cdef cprrt.PrrtCodingParams *params = cprrt.PrrtSocket_get_coding_parameters(self._c_socket)
            result = PrrtCodingConfiguration(params.n, params.k, list(<uint8_t[:params.c]> params.n_cycle))
            return result

        def __set__(self, params: PrrtCodingConfiguration):
            cdef uint8_t* n_cycle
            c = len(params.n_cycle)
            n_cycle = <uint8_t *> malloc(c * cython.sizeof(int))
            for i, x in enumerate(params.n_cycle):
              n_cycle[i] = x
            cprrt.PrrtSocket_set_coding_parameters(self._c_socket, params.k, params.n, c, n_cycle)

    property delivery_rate:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_delivery_rate(self._c_socket)

    property btlbw:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_btlbw(self._c_socket)

    property bbr_state:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_bbr_state(self._c_socket)

    property bbr_filled_pipe:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_filled_pipe(self._c_socket)


    property bbr_full_bw:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_full_bw(self._c_socket)

    property bbr_cycle_index:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_cycle_index(self._c_socket)

    property bbr_pacing_gain:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_pacing_gain(self._c_socket)

    property bbr_cwnd:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_cwnd(self._c_socket)

    property bbr_inflight:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_inflight(self._c_socket)

    property bbr_pacing_rate:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_pacing_rate(self._c_socket)

    property bbr_send_quantum:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_send_quantum(self._c_socket)

    property app_limited:
        def __get__(self):
            if not self.isSender:
                raise Exception("Not a sender.")
            return cprrt.PrrtSocket_get_app_limited(self._c_socket)

    def recv(self):
        cdef char buffer[65536]
        cdef int32_t len
        with nogil:
            len = cprrt.PrrtSocket_recv(self._c_socket, <void*> buffer)
        return buffer[:len]

    def receive_asap(self):
        cdef char buffer[65536]
        cdef int32_t len
        with nogil:
            len = cprrt.PrrtSocket_receive_asap(self._c_socket, <void*> buffer)
        return buffer[:len]

    def receive_asap_wait(self):
        cdef char buffer[65536]
        cdef int32_t len
        with nogil:
            len = cprrt.PrrtSocket_receive_asap_wait(self._c_socket, <void*> buffer)
        return buffer[:len]

    def receive_asap_timedwait(self, deadline):
        cdef char buffer[65536]
        cdef int32_t len
        cdef timespec deadline_timespec = timespec(deadline.seconds, deadline.microseconds * 1000)
        with nogil:
            len = cprrt.PrrtSocket_receive_asap_timedwait(self._c_socket, <void*> buffer, &deadline_timespec)
        return buffer[:len]

    def receive_ordered(self, time_window):
        cdef char buffer[65536]
        cdef int32_t len
        cdef uint32_t time_window_us = time_window * (1000**2)
        with nogil:
            len = cprrt.PrrtSocket_receive_ordered(self._c_socket, <void*> buffer, time_window_us)
        return buffer[:len]

    def receive_ordered_wait(self, time_window):
        cdef char buffer[65536]
        cdef int32_t len
        cdef uint32_t time_window_us = time_window * (1000**2)
        with nogil:
            len = cprrt.PrrtSocket_receive_ordered_wait(self._c_socket, <void*> buffer, time_window_us)
        return buffer[:len]

    def receive_ordered_timedwait(self, time_window, deadline):
        cdef char buffer[65536]
        cdef int32_t len
        cdef uint32_t time_window_us = time_window * (1000**2)
        cdef timespec deadline_timespec = timespec(deadline.seconds, deadline.microseconds * 1000)
        with nogil:
            len = cprrt.PrrtSocket_receive_ordered_timedwait(self._c_socket, <void*> buffer, time_window_us, &deadline_timespec)
        return buffer[:len]

    def connect(self, host, port):
        cdef bytes encodedHost = host.encode("utf-8")
        cprrt.PrrtSocket_connect(self._c_socket, encodedHost, port)

    def send(self, data):
        cprrt.PrrtSocket_send(self._c_socket, data, len(data))

    def __dealloc__(self):
        if self._c_socket != NULL:
            cprrt.PrrtSocket_close(self._c_socket)