Commit 6191755a authored by Andreas Schmidt's avatar Andreas Schmidt
Browse files

Refactor CodingConfiguration and coder.

parent dd704aab

prrt/cprrt.pxd

+7 −8
Original line number Diff line number Diff line
@@ -26,18 +26,17 @@ cdef extern from "proto/channelStateInformation.h": 
    ctypedef prrtChannelStateInformation PrrtChannelStateInformation



cdef extern from "proto/codingParams.h":

    ctypedef struct prrtCodingParams:

    ctypedef struct prrtCodingConfiguration:

        uint8_t k

        uint8_t r

        uint8_t n

        uint8_t c

        uint8_t *n_cycle



    ctypedef prrtCodingParams PrrtCodingParams

    PrrtCodingParams *PrrtCodingParams_create()

    PrrtCodingParams *PrrtCodingParams_copy(PrrtCodingParams *cpar)

    bint PrrtCodingParams_update(PrrtCodingParams *cpar, uint8_t k, uint8_t n, uint8_t c, uint8_t *n_cycle)

    bint PrrtCodingParams_destroy(PrrtCodingParams *cpar)

    ctypedef prrtCodingConfiguration PrrtCodingConfiguration

    PrrtCodingConfiguration *PrrtCodingConfiguration_create()

    PrrtCodingConfiguration *PrrtCodingConfiguration_copy(PrrtCodingConfiguration *cpar)

    bint PrrtCodingConfiguration_destroy(PrrtCodingConfiguration *cpar)



cdef extern from "util/list.h":

    cdef struct list:
@@ -62,7 +61,7 @@ cdef extern from "proto/block.h": 
    cdef struct prrtBlock:

        uint32_t data_count

        uint32_t redundancy_count

        PrrtCodingParams coding_params

        PrrtCodingConfiguration coding_params

        uint32_t largest_data_length

        uint16_t baseSequenceNumber

        List* data_blocks
@@ -138,7 +137,7 @@ cdef extern from "proto/socket.h": 
    bint PrrtSocket_set_sock_opt(PrrtSocket *sock_ptr, const_char *name, const uint32_t value)

    uint32_t PrrtSocket_get_sock_opt(PrrtSocket *sock_ptr, const_char *name)

    bint PrrtSocket_set_coding_parameters(PrrtSocket *s, uint8_t k, uint8_t n, uint8_t c, uint8_t *n_cycle)

    PrrtCodingParams *PrrtSocket_get_coding_parameters(PrrtSocket *s)

    PrrtCodingConfiguration *PrrtSocket_get_coding_parameters(PrrtSocket *s)

    bint PrrtSocket_uses_thread_pinning(PrrtSocket *socket)

    uint32_t PrrtSocket_get_rtprop(PrrtSocket *socket)

prrt/proto/block.c

+12 −8
Original line number Diff line number Diff line
@@ -57,6 +57,14 @@ bool PrrtBlock_destroy(PrrtBlock *block_ptr) 
        PrrtPacket_destroy(pkt);

    }



    if(block_ptr->coder != NULL) {

        PrrtCoder_destroy(block_ptr->coder);

    }



    if(block_ptr->codingParams != NULL) {

        PrrtCodingConfiguration_destroy(block_ptr->codingParams);

    }



    List_destroy(block_ptr->dataPackets);

    List_destroy(block_ptr->redundancyPackets);

    free(block_ptr);
@@ -68,17 +76,17 @@ bool PrrtBlock_destroy(PrrtBlock *block_ptr) 
    return false;

}



PrrtBlock * PrrtBlock_create(PrrtCodingParams *cpar, prrtSequenceNumber_t baseSequenceNumber)

PrrtBlock * PrrtBlock_create(PrrtCodingConfiguration *cpar, PrrtCoder* coder, prrtSequenceNumber_t baseSequenceNumber)

{

    PrrtBlock *block_ptr = calloc(1, sizeof(PrrtBlock));

    check_mem(block_ptr);



    block_ptr->coder = coder;

    block_ptr->codingParams = cpar;

    block_ptr->dataPackets = List_create();

    block_ptr->redundancyPackets = List_create();

    block_ptr->baseSequenceNumber = baseSequenceNumber;

    block_ptr->largestPayloadLength = 0;

    block_ptr->coder = NULL;



    pthread_mutexattr_t attr;

    check(pthread_mutexattr_init(&attr) == EXIT_SUCCESS, "Mutex attr init failed.");
@@ -184,8 +192,6 @@ void PrrtBlock_encode(PrrtBlock *block_ptr, prrtSequenceNumber_t *seqno) 
    prrtSequenceNumber_t baseSequenceNumber = block_ptr->baseSequenceNumber;

    prrtPacketLength_t length = block_ptr->largestPayloadLength;



    PrrtCoder *coder = block_ptr->codingParams->coder;



    gf **src = calloc(k, sizeof(gf *));

    check_mem(src);
@@ -203,7 +209,7 @@ void PrrtBlock_encode(PrrtBlock *block_ptr, prrtSequenceNumber_t *seqno) 
    for(j = 0; j < r; j++) {

        fec[j] = calloc(length, sizeof(gf));

        check_mem(fec[j]);

        PrrtCoder_encode(coder, src, fec[j], j + k, length);

        PrrtCoder_encode(block_ptr->coder, src, fec[j], j + k, length);

        PrrtPacket *red_packet_ptr = PrrtPacket_create_redundancy_packet(0, (void *) fec[j], length, *seqno,

                                                                         (uint8_t) (k + j), block_ptr->baseSequenceNumber,

                                                                         block_ptr->codingParams);
@@ -237,8 +243,6 @@ bool PrrtBlock_decode(PrrtBlock *block_ptr) 
    prrtSequenceNumber_t baseSequenceNumber = block_ptr->baseSequenceNumber;

    prrtPacketLength_t length = block_ptr->largestPayloadLength;



    PrrtCoder *coder = block_ptr->codingParams->coder;



    fec = calloc(k, sizeof(gf *));

    check_mem(fec);

    for(i = 0; i < k; i++) {
@@ -254,7 +258,7 @@ bool PrrtBlock_decode(PrrtBlock *block_ptr) 
    gather_data_packets(block_ptr, fec, idx_p);

    gather_redundancy_packets(block_ptr, fec, idx_p);



    check(PrrtCoder_decode(coder, fec, idx_p, length) == EXIT_SUCCESS, "Could not decode current block.");

    check(PrrtCoder_decode(block_ptr->coder, fec, idx_p, length) == EXIT_SUCCESS, "Could not decode current block.");



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

        if(idx_p[j] >= k) {

prrt/proto/block.h

+3 −3
Original line number Diff line number Diff line
@@ -8,21 +8,21 @@ 
#include "vdmcode/block_code.h"



typedef struct prrtBlock {

    PrrtCodingParams* codingParams;

    PrrtCodingConfiguration* codingParams;

    prrtPacketLength_t largestPayloadLength;

    prrtSequenceNumber_t baseSequenceNumber;

    List*dataPackets;

    List*redundancyPackets;

    bool isCoded;

    PrrtCoder *coder;

    pthread_mutex_t lock;

    PrrtCoder *coder;

} PrrtBlock;





/**

 * Allocate space for a block.

 */

PrrtBlock * PrrtBlock_create(PrrtCodingParams *cpar, prrtSequenceNumber_t baseSequenceNumber);

PrrtBlock * PrrtBlock_create(PrrtCodingConfiguration *cpar, PrrtCoder* coder, prrtSequenceNumber_t baseSequenceNumber);



/**

 * Frees the PrrtBlock data structure.

prrt/proto/codingParams.c

+19 −52
Original line number Diff line number Diff line
@@ -2,70 +2,37 @@ 
#include "../util/common.h"

#include "../util/dbg.h"

#include "../defines.h"

#include "codingParams.h"



PrrtCodingParams *PrrtCodingParams_create(void)

{

    PrrtCodingParams *cpar = calloc(1, sizeof(PrrtCodingParams));

    check_mem(cpar);

    pthread_mutex_init(&cpar->lock, NULL);

    cpar->coder = NULL;



    uint8_t* n_cycle = calloc(1, sizeof(uint8_t));

    n_cycle[0] = N_START - K_START;

    PrrtCodingParams_update(cpar, K_START, N_START, 1, n_cycle);

PrrtCodingConfiguration *PrrtCodingConfiguration_create(uint8_t k, uint8_t n, uint8_t c, uint8_t *n_cycle)

{

    PrrtCodingConfiguration *cc = calloc(1, sizeof(PrrtCodingConfiguration));

    check_mem(cc);

    cc->k = k;

    cc->n = n;

    cc->r = cc->n - cc->k;

    cc->c = c;

    if(n_cycle != NULL) {

        cc->n_cycle = (uint8_t*) realloc(cc->n_cycle, cc->c * sizeof(int8_t));

        memcpy(cc->n_cycle, n_cycle, cc->c * sizeof(int8_t));

    }



    return cpar;

    return cc;



    error:

    PERROR("Memory issue.%s","");

    return NULL;

}



bool PrrtCodingParams_update(PrrtCodingParams *cpar, uint8_t k, uint8_t n, uint8_t c, uint8_t *n_cycle) {

    cpar->k = k;

    cpar->n = n;

    cpar->r = cpar->n - cpar->k;

    cpar->c = c;

    if(cpar->n_cycle != NULL) {

        free(cpar->n_cycle);

    }

    cpar->n_cycle = n_cycle;

    PrrtCoder_get_coder(&cpar->coder, n, k);

    return true;

}



PrrtCodingParams* PrrtCodingParams_copy(PrrtCodingParams *cpar) {

    PrrtCodingParams *result = PrrtCodingParams_create();

    check(pthread_mutex_lock(&cpar->lock) == EXIT_SUCCESS, "Lock failed.");



    result->k = cpar->k;

    result->n = cpar->n;

    result->r = cpar->r;

    result->c = cpar->c;



    result->n_cycle = (uint8_t*) realloc(result->n_cycle, result->c * sizeof(int8_t));

    memcpy(result->n_cycle, cpar->n_cycle, result->c * sizeof(int8_t));



    // PrrtCoder_get_coder(&result->coder, result->n, result->k); // TODO



    check(pthread_mutex_unlock(&cpar->lock) == EXIT_SUCCESS, "Unlock failed");

    return result;



error:

    PERROR("Could not copy%s", "");

    return NULL;

PrrtCodingConfiguration *PrrtCodingConfiguration_copy(PrrtCodingConfiguration *codingConfiguration) {

    return PrrtCodingConfiguration_create(codingConfiguration->k, codingConfiguration->n, codingConfiguration->c, codingConfiguration->n_cycle);

}



bool PrrtCodingParams_destroy(PrrtCodingParams * cpar) {

    pthread_mutex_destroy(&cpar->lock);



    PrrtCoder_destroy(cpar->coder);



    if(cpar->n_cycle != NULL) {

        free(cpar->n_cycle);

bool PrrtCodingConfiguration_destroy(PrrtCodingConfiguration *codingConfiguration) {

    if(codingConfiguration->n_cycle != NULL) {

        free(codingConfiguration->n_cycle);

    }



    free(cpar);

    free(codingConfiguration);

    return true;

}

prrt/proto/codingParams.h

+5 −11
Original line number Diff line number Diff line
@@ -4,23 +4,17 @@ 
#include <pthread.h>

#include <stdint.h>

#include <stdbool.h>

#include "vdmcode/block_code.h"



typedef struct prrtCodingParams {

    pthread_mutex_t lock;



typedef struct prrtCodingConfiguration {

    uint8_t k;

    uint8_t r;

    uint8_t n;

    uint8_t c;

    uint8_t* n_cycle;

} PrrtCodingConfiguration;



    PrrtCoder* coder;

} PrrtCodingParams;



PrrtCodingParams * PrrtCodingParams_create(void);

PrrtCodingParams * PrrtCodingParams_copy(PrrtCodingParams *cpar);

bool PrrtCodingParams_update(PrrtCodingParams * cpar, uint8_t k, uint8_t n, uint8_t c, uint8_t *n_cycle);

bool PrrtCodingParams_destroy(PrrtCodingParams * cpar);

PrrtCodingConfiguration *PrrtCodingConfiguration_create(uint8_t k, uint8_t n, uint8_t c, uint8_t *n_cycle);

PrrtCodingConfiguration *PrrtCodingConfiguration_copy(PrrtCodingConfiguration *codingConfiguration);

bool PrrtCodingConfiguration_destroy(PrrtCodingConfiguration *codingConfiguration);



#endif //PRRT_CODING_PARAMS_H