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/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=None):
        if n < k:
            raise ValueError("n must be greater or equal k.")
        self.n = n
        self.k = k
        self.r = n - k

        if self.r != 0:
            if n_cycle is None:
                raise ValueError("n_cycle cannot be None if n == k.")
            elif sum(n_cycle) != (n-k):
                raise ValueError("The elements in n_cycle must sum up to n-k.")

        self.n_cycle = n_cycle if n_cycle is not None else [0]

    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)


cdef class PrrtSocket:
    cdef cprrt.PrrtSocket* _c_socket

    def __cinit__(self, port, target_delay = 1, thread_pinning = False):
        target_delay_us = target_delay * 1000**2
        self._c_socket = cprrt.PrrtSocket_create(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)


    property plr_fwd:
        def __get__(self):
            return cprrt.PrrtSocket_get_plr_fwd(self._c_socket)

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

    property target_delay:
        def __get__(self):
            return cprrt.PrrtSocket_get_sock_opt(self._c_socket, "targetdelay") * 0.000001

    property app_queue_size:
        def __get__(self):
            return cprrt.PrrtSocket_get_sock_opt(self._c_socket, "app_queue_size")

        def __set__(self, value):
            cprrt.PrrtSocket_set_sock_opt(self._c_socket, "app_queue_size", value)

    property rtt_fwd:
        def __get__(self):
            return cprrt.PrrtSocket_get_rtprop_fwd(self._c_socket) * 0.000001

    property coding_configuration:
        def __get__(self):
            cdef cprrt.PrrtCodingConfiguration *params = cprrt.PrrtSocket_get_coding_parameters(self._c_socket)
            return PrrtCodingConfiguration(params.n, params.k, list(<uint8_t[:params.c]> params.n_cycle))

        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_fwd:
        def __get__(self):
            return cprrt.PrrtSocket_get_delivery_rate_fwd(self._c_socket)

    property btlbw_fwd:
        def __get__(self):
            return cprrt.PrrtSocket_get_btlbw_fwd(self._c_socket)

    property btlbw_back:
        def __get__(self):
            return cprrt.PrrtSocket_get_btlbw_back(self._c_socket)

    property bbr_state:
        def __get__(self):
            return cprrt.PrrtSocket_get_bbr_state(self._c_socket)

    property bbr_filled_pipe:
        def __get__(self):
            return cprrt.PrrtSocket_get_filled_pipe(self._c_socket)

    property bbr_full_bw:
        def __get__(self):
            return cprrt.PrrtSocket_get_full_bw(self._c_socket)

    property bbr_cycle_index:
        def __get__(self):
            return cprrt.PrrtSocket_get_cycle_index(self._c_socket)

    property bbr_pacing_gain:
        def __get__(self):
            return cprrt.PrrtSocket_get_pacing_gain(self._c_socket)

    property bbr_cwnd:
        def __get__(self):
            return cprrt.PrrtSocket_get_cwnd(self._c_socket)

    property bbr_inflight:
        def __get__(self):
            return cprrt.PrrtSocket_get_inflight(self._c_socket)

    property bbr_pacing_rate:
        def __get__(self):
            return cprrt.PrrtSocket_get_pacing_rate(self._c_socket)

    property bbr_send_quantum:
        def __get__(self):
            return cprrt.PrrtSocket_get_send_quantum(self._c_socket)

    property bbr_pipe:
        def __get__(self):
            return cprrt.PrrtSocket_get_pipe(self._c_socket)

    property bbr_delivered:
        def __get__(self):
            return cprrt.PrrtSocket_get_delivered(self._c_socket)

    property bbr_is_app_limited:
        def __get__(self):
            return cprrt.PrrtSocket_get_bbr_is_app_limited(self._c_socket)

    property bbr_app_limited:
        def __get__(self):
            return cprrt.PrrtSocket_get_bbr_app_limited(self._c_socket)

    property bbr_round_start:
        def __get__(self):
            return cprrt.PrrtSocket_get_bbr_round_start(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)