Commit 83bc59c4 authored by Andreas Schmidt's avatar Andreas Schmidt
Browse files

Add NSDI changes.

parent db7bcf84

prrt/cprrt.pxd

+2 −1
Original line number Diff line number Diff line
@@ -123,7 +123,8 @@ cdef extern from "proto/socket.h": 
    bint PrrtSocket_bind(PrrtSocket *sock_ptr, const_char *ipAddress, const uint16_t port)

    int PrrtSocket_close(const PrrtSocket *sock_ptr)

    int PrrtSocket_connect(PrrtSocket *sock_ptr, const_char *host, const uint16_t port)

    int PrrtSocket_send(PrrtSocket *sock_ptr, const uint8_t *data, const size_t data_len)

    int PrrtSocket_send_sync(PrrtSocket *sock_ptr, const uint8_t *data, const size_t data_len)

    int PrrtSocket_send_async(PrrtSocket *sock_ptr, const uint8_t *data, const size_t data_len)



    int32_t PrrtSocket_recv(PrrtSocket *sock_ptr, void *buf_ptr, sockaddr* addr) nogil

    int32_t PrrtSocket_receive_asap(PrrtSocket *s, void *buf_ptr, sockaddr* addr) nogil

prrt/defines.h

+2 −2
Original line number Diff line number Diff line
@@ -30,8 +30,8 @@ 


#define GF_BITS 8



#define K_START 4

#define N_START 7

#define K_START 1

#define N_START 1

#define N_P_START 1



#define RRT_ALPHA 0.125

prrt/proto/CMakeLists.txt

+2 −0
Original line number Diff line number Diff line
@@ -12,6 +12,8 @@ set (PRRT_SOURCES ../defines.h 
        stores/dataPacketStore.c stores/dataPacketStore.h

        stores/deliveredPacketTable.c stores/deliveredPacketTable.h

        stores/inFlightPacketStore.c stores/inFlightPacketStore.h

        stores/pace.c stores/pace.h

        stores/paceFilter.c stores/paceFilter.h

        stores/packetTimeoutTable.c stores/packetTimeoutTable.h

        stores/packetDeliveryStore.c stores/packetDeliveryStore.h

        stores/receptionTable.c stores/receptionTable.h

prrt/proto/processes/dataReceiver.c

+12 −2
Original line number Diff line number Diff line
@@ -86,11 +86,13 @@ static bool send_feedback(PrrtSocket *sock_ptr, struct sockaddr_in remote, prrtS 
    PrrtLossStatistics stats = sock_ptr->lossStatistics;



    int group_RTT = 0; // TODO: To be determined.

    uint32_t local_bottleneck_pace = MAX(PrrtPace_get_diff(sock_ptr->appDeliverPace), PrrtPace_get_max(sock_ptr->prrtReceivePace));

    PrrtPacket *feedback_pkt_ptr = PrrtPacket_create_feedback_packet(0, sock_ptr->sequenceNumberFeedback++, group_RTT,

                                                                     stats.gapLength, stats.gapCount, stats.burstLength,

                                                                     stats.burstCount, forwardTripTime,

                                                                     stats.erasureCount, stats.packetCount, feedback.seqNo,

                                                                     feedback.type);

                                                                     stats.erasureCount, stats.packetCount,

                                                                     feedback.seqNo, feedback.type,

                                                                     local_bottleneck_pace);

    prrtPacketLength_t length = PrrtPacket_size(feedback_pkt_ptr);

    void *buf = calloc(1, length);

    check_mem(buf);
@@ -142,6 +144,7 @@ handle_data_packet(PrrtSocket *sock_ptr, PrrtPacket *packet) { 
        PrrtPacket_destroy(packet);

    } else {

        PrrtChannelStateInformation_update_delivery_rate(sock_ptr->senderChannelStateInformation, payload->btlbw);

        sock_ptr->send_peer_btl_pace = payload->btl_pace;

        prrtSequenceNumber_t baseSequenceNumber = packet->sequenceNumber - packet->index;



        PrrtPacket *reference = PrrtPacket_copy(packet);
@@ -187,6 +190,7 @@ static void handle_redundancy_packet(PrrtSocket *socket, PrrtPacket *packet) { 
    } else {

        PrrtBlock *block = PrrtRepairBlockStore_get_block(socket->repairBlockStore,

                                                          redundancyPayload->baseSequenceNumber);

        socket->send_peer_btl_pace = payload->btl_pace;

        if (block == NULL) {

            PrrtCodingConfiguration* codingParams = PrrtCodingConfiguration_create(redundancyPayload->k,

                                                                                   redundancyPayload->n, 0, NULL);
@@ -214,6 +218,7 @@ void handle_feedback_packet(PrrtSocket *prrtSocket, PrrtPacket *prrtPacket, prrt 
    prrtTimestamp_t forwardTripTimestamp = feedbackPayload->forwardTripTimestamp_us;



    prrtTimedelta_t rtt = (prrtTimedelta_t) (receiveTime - forwardTripTimestamp);

    prrtSocket->recv_peer_btl_pace = feedbackPayload->btl_pace;



    PrrtReceiver_on_ack(prrtSocket->receiver, feedbackPayload, receiveTime, rtt);

    return;
@@ -274,6 +279,7 @@ void *receive_data_loop(void *ptr) { 
    PrrtSocket *s = ptr;



    while (1) {

        PrrtPace_track_start(s->prrtReceivePace);

        debug(DEBUG_DATARECEIVER, "About to receive.");

        XlapTimestampPlaceholder tsph1;

        XlapTimestampPlaceholder tsph2;
@@ -284,6 +290,9 @@ void *receive_data_loop(void *ptr) { 


        struct timespec packet_recv_timestamp;

        uint64_t packet_recv_cyclestamp = 0;

        PrrtPace_track_pause(s->prrtReceivePace);

        receive_from_socket(s, buffer, &n, &remote, &addrlen, &packet_recv_timestamp, &packet_recv_cyclestamp);

        PrrtPace_track_resume(s->prrtReceivePace);

        receive_from_socket(s, buffer, &n, &remote, &addrlen, &packet_recv_timestamp, &packet_recv_cyclestamp);

        if (atomic_load_explicit(&s->closing, memory_order_acquire)) {

            break;
@@ -350,6 +359,7 @@ void *receive_data_loop(void *ptr) { 
        debug(DEBUG_DATARECEIVER, "Cleanup");

        PrrtSocket_cleanup(s);

        debug(DEBUG_DATARECEIVER, "Cleaned");

        PrrtPace_track_end(s->prrtReceivePace);

    }

    PrrtSocket_cleanup(s);

    return NULL;

prrt/proto/processes/dataTransmitter.c

+65 −48
Original line number Diff line number Diff line
@@ -77,8 +77,7 @@ static bool send_packet(PrrtSocket *sock_ptr, PrrtPacket *packet) { 
    uint8_t buf[MAX_PAYLOAD_LENGTH];

    memset(buf, 0, sizeof(buf));

    prrtPacketLength_t length = PrrtPacket_size(packet);

    prrtPacketLength_t payloadLength = packet->payloadLength;

    PrrtSocket_pace(sock_ptr);

    PrrtSocket_pace(sock_ptr, true);



    int64_t space = PrrtReceiver_get_space(sock_ptr->receiver);

    while (space < sock_ptr->maximum_payload_size) {
@@ -89,19 +88,32 @@ static bool send_packet(PrrtSocket *sock_ptr, PrrtPacket *packet) { 


    prrtTimestamp_t now = PrrtClock_get_current_time_us();

    if (sock_ptr->pacingEnabled) {

        double pacing_rate = PrrtReceiver_getBBRPacingRate(sock_ptr->receiver);

        prrtTimedelta_t peerPacingTime = 0;

        prrtTimedelta_t channelPacingTime = 0;

        double pacing_rate = PrrtReceiver_get_BBR_pacingRate(sock_ptr->receiver);

        double pacing_gain = PrrtReceiver_get_BBR_pacingGain(sock_ptr->receiver);

        uint32_t state = PrrtReceiver_get_BBR_state(sock_ptr->receiver);

        if(pacing_rate != 0) {

            prrtTimedelta_t pacingTime = (prrtTimedelta_t) round(((1000 * 1000 * ( (double)payloadLength)) / pacing_rate));

            channelPacingTime = (prrtTimedelta_t) round(((1000 * 1000 * ((double) packet->payloadLength)) / pacing_rate));

        }

        // Cross-Pace iff PROBE_BW and unity gain

        if(state == PROBE_BW && pacing_gain == 1.0 && sock_ptr->recv_peer_btl_pace != 0) {

            peerPacingTime = 0; //(prrtTimedelta_t) round(sock_ptr->recv_peer_btl_pace);

        }

        

        prrtTimedelta_t pacingTime = (prrtTimedelta_t) round(MAX(channelPacingTime, peerPacingTime));

        debug(DEBUG_DATATRANSMITTER, "Payload: %u, PacingRate: %f, Pacing Time: %u", packet->payloadLength, pacing_rate, pacingTime);

        sock_ptr->nextSendTime = now + pacingTime;

    }

    }

    // Update timestamp

    prrtTimedelta_t btl_pace = MAX(PrrtPace_get_max(sock_ptr->prrtTransmitPace), PrrtPace_get_max(sock_ptr->appSendPace));

    if(PrrtPacket_type(packet) == PACKET_TYPE_DATA) {

        ((PrrtPacketDataPayload*) (packet->payload))->timestamp = PrrtClock_get_current_time_us();

        ((PrrtPacketDataPayload*) (packet->payload))->btlbw = PrrtReceiver_get_BBR_btlDr(sock_ptr->receiver);

        ((PrrtPacketDataPayload*) (packet->payload))->btl_pace = btl_pace;

    } else if(PrrtPacket_type(packet) == PACKET_TYPE_REDUNDANCY) {

        ((PrrtPacketRedundancyPayload*) (packet->payload))->timestamp = PrrtClock_get_current_time_us();

        ((PrrtPacketRedundancyPayload*) (packet->payload))->btl_pace = btl_pace;

    }



    check(PrrtPacket_encode(buf, MAX_PAYLOAD_LENGTH, packet), "Buffer too small.");
@@ -143,7 +155,6 @@ static bool send_packet(PrrtSocket *sock_ptr, PrrtPacket *packet) { 
        case PACKET_TYPE_CHANNEL_FEEDBACK:

        default:;

    }



    return true;



    error:
@@ -151,29 +162,15 @@ static bool send_packet(PrrtSocket *sock_ptr, PrrtPacket *packet) { 
    return false;

}



void *send_data_loop(void *ptr) {

    PrrtSocket *sock_ptr = ptr;

    PrrtBlock *block = NULL;



    while (1) {

        ListNode *job;

        do {

            job = Pipe_pull(sock_ptr->sendDataQueue);

            if (PrrtSocket_closing(sock_ptr)) {

                if (block != NULL) {

                    PrrtBlock_destroy(block);

                }

                return NULL;

            }

        } while (!job);

        PrrtPacket *packet = PrrtPacket_byListNode(job);

void PrrtDataTransmitter_transmit(PrrtSocket *sock_ptr, PrrtPacket *packet) {

    PrrtPace_track_start(sock_ptr->prrtTransmitPace);

    XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitStart);

    XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitStart);

        if (block == NULL) {

            block = PrrtBlock_create(PrrtCodingConfiguration_copy(sock_ptr->codingParameters), PrrtCoder_copy(sock_ptr->coder), packet->sequenceNumber);

    if (sock_ptr->receiveBlock == NULL) {

        sock_ptr->receiveBlock = PrrtBlock_create(PrrtCodingConfiguration_copy(sock_ptr->codingParameters), PrrtCoder_copy(sock_ptr->coder), packet->sequenceNumber);

    }



        packet->index = (uint8_t) (packet->sequenceNumber - block->baseSequenceNumber);

    packet->index = (uint8_t) (packet->sequenceNumber - sock_ptr->receiveBlock->baseSequenceNumber);



    PrrtPacketDataPayload *payload = packet->payload;

    payload->groupRTprop_us = PrrtSocket_get_rtprop_fwd(sock_ptr);
@@ -184,24 +181,44 @@ void *send_data_loop(void *ptr) { 
    XlapTimeStampClock(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitEnd);

    XlapTimeStampCycle(sock_ptr, ts_data_packet, packet->sequenceNumber, PrrtTransmitEnd);



        PrrtBlock_insert_data_packet(block, packet);

    PrrtBlock_insert_data_packet(sock_ptr->receiveBlock, packet);



    // TODO: redundancy should only be sent when necessary

        if (PrrtBlock_encode_ready(block)) {

    if (PrrtBlock_encode_ready(sock_ptr->receiveBlock)) {

        uint32_t j = 0;

        unsigned int redundancy_seqno = sock_ptr->sequenceNumberRedundancy;

        XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, redundancy_seqno, PrrtEncodeStart);

            PrrtBlock_encode(block, &sock_ptr->sequenceNumberRedundancy);

        PrrtBlock_encode(sock_ptr->receiveBlock, &sock_ptr->sequenceNumberRedundancy);

        XlapTimeStampCycle(sock_ptr, ts_redundancy_packet, redundancy_seqno, PrrtEncodeEnd);



            uint32_t redundancyPackets = List_count(block->redundancyPackets);

        uint32_t redundancyPackets = List_count(sock_ptr->receiveBlock->redundancyPackets);

        for (j = 0; j < redundancyPackets; j++) {

                PrrtPacket *red_pkt = PrrtBlock_get_first_red_data(block);

            PrrtPacket *red_pkt = PrrtBlock_get_first_red_data(sock_ptr->receiveBlock);

            send_packet(sock_ptr, red_pkt);

        }



            PrrtBlock_destroy(block);

            block = NULL;

        PrrtBlock_destroy(sock_ptr->receiveBlock);

        sock_ptr->receiveBlock = NULL;

    }

    PrrtPace_track_end(sock_ptr->prrtTransmitPace);

}



void *PrrtDataTransmitter_send_data_loop(void *ptr) {

    PrrtSocket *sock_ptr = ptr;



    while (1) {

        ListNode *job;

        do {

            job = Pipe_pull(sock_ptr->sendDataQueue);

            if (PrrtSocket_closing(sock_ptr)) {

                if (sock_ptr->receiveBlock != NULL) {

                    PrrtBlock_destroy(sock_ptr->receiveBlock);

                    sock_ptr->receiveBlock = NULL;

                }

                return NULL;

            }

        } while (!job);

        PrrtPacket *packet = PrrtPacket_byListNode(job);

        PrrtDataTransmitter_transmit(sock_ptr, packet);

    }

}