LDGM_session Class Reference

Parent class for CPU and GPU implementations of LDGM coding. More...

#include <ldgm-session.h>

Inheritance diagram for LDGM_session:

Collaboration diagram for LDGM_session:

Public Member Functions
	LDGM_session ()
virtual	~LDGM_session ()
virtual void *	alloc_buf (int size)=0
void	create_edges (Tanner_graph *g)
virtual char *	decode_frame (char *received_data, int buf_size, int *frame_size, std::map< int, int > valid_data)=0
virtual void	encode (char *data, char *parity)=0
char *	encode_frame (char *frame, int frame_size, int *out_buf_size)
char *	encode_hdr_frame (char *hdr, int hdr_size, char *frame, int frame_size, int *out_buf_size)
virtual void	encode_naive (char *data, char *parity)=0
virtual void	free_out_buf (char *buf)=0
unsigned int	get_packet_size () const
bool	needs_decoding (Tanner_graph *tanner_graph)
void	set_params (unsigned short k, unsigned short m, unsigned short rw)
void	set_pcMatrix (char *matrix)
Public Member Functions inherited from Coding_session

Protected Attributes
double	elapsed_sum2
char *	lost_ptr
unsigned short	max_row_weight
long	no_frames2
unsigned short	packet_size
unsigned short	param_k
unsigned short	param_m
int *	pcm
char *	pcMatrix
char *	received_ptr
unsigned short	row_weight

Static Protected Attributes
static const int	HEADER_SIZE = 4

Detailed Description

Parent class for CPU and GPU implementations of LDGM coding.

This class implements common mechanisms used during LDGM coding, however actual coding implementation has to be provided in child classes.

Definition at line 36 of file ldgm-session.h.

Constructor & Destructor Documentation

LDGM_session()

LDGM_session::LDGM_session ( )

inline

Definition at line 40 of file ldgm-session.h.

                        :                          /* constructor **/
                pcMatrix(NULL), pcm(NULL), param_k(0), param_m(0), row_weight(0),
                packet_size(0), max_row_weight(0), received_ptr(NULL),
                lost_ptr(NULL), elapsed_sum2(0.0), no_frames2(0)
        {
        }

~LDGM_session()

LDGM_session::~LDGM_session ( )

virtual

Definition at line 410 of file ldgm-session.cpp.

                            {
    free(pcm);
}

References pcm.

Member Function Documentation

alloc_buf()

virtual void * LDGM_session::alloc_buf ( int size )

pure virtual

Implemented in LDGM_session_cpu, and LDGM_session_gpu.

Referenced by encode_frame(), and encode_hdr_frame().

create_edges()

void LDGM_session::create_edges

(

Tanner_graph *

g

)

Definition at line 357 of file ldgm-session.cpp.

{
//    printf ( "graph: %p, param_k: %d, param_m: %d\n", graph, param_k, param_m );
    for ( int m = 0; m < param_m; ++m) {
        for ( int k = 0; k < max_row_weight+2; ++k ) {
            int idx = pcm [ m*(max_row_weight+2) + k];
            if( idx > -1 ) {
                auto &node = graph->nodes.at(idx);
                node.neighbours.push_back(param_k + param_m + m);
                auto &n2 = graph->nodes.at(param_k + param_m + m);
                n2.neighbours.push_back(idx);
            }
        }
    }
    /*     it = graph->nodes.find(0);
     *     while ( it != graph->nodes.end() )
     *     {
     *  printf ( "\nneighbours of node %d: ", it->first );
     *  for (vector<int>::iterator i = it->second.neighbours.begin();
     *          i != it->second.neighbours.end(); ++i)
     *      printf ( "%d, ", *i );
     *  it++;
     *     }
     */
 
    //add edges representing the staircase matrix
    /*     for ( int i = param_k + param_m; i < param_k + 2*param_m; ++i) {
     *  it = graph->nodes.find(i);
     *  (*it).second.neighbours.push_back(i - param_m);
     *  it = graph->nodes.find(i - param_m);
     *  (*it).second.neighbours.push_back(i);
     *  if(i > param_m + param_k) {
     *      it = graph->nodes.find(i);
     *      (*it).second.neighbours.push_back(i - param_m - 1);
     *      it = graph->nodes.find(i - param_m - 1);
     *      (*it).second.neighbours.push_back(i);
     *  }
     *     }
     */
    return ;
}               /*  -----  end of function create_edges  ----- */

References max_row_weight, Tanner_graph::nodes, param_k, param_m, and pcm.

Referenced by LDGM_session_cpu::decode_frame().

decode_frame()

virtual char * LDGM_session::decode_frame ( char * received_data, int buf_size, int * frame_size, std::map< int, int > valid_data )

pure virtual

Method decode should recover original source data

Parameters

received_data	Received data (source and parity)
buf_size	Size of the received buffer
frame_size	Output parameter for storing size of the decoded frame
valid_data	Map storing pairs <offset, number of bytes> of received data

Returns

Recovered source data

Implements Coding_session.

Implemented in LDGM_session_cpu, and LDGM_session_gpu.

encode()

virtual void LDGM_session::encode ( char * data, char * parity )

pure virtual

Implemented in LDGM_session_cpu, and LDGM_session_gpu.

Referenced by encode_frame(), and encode_hdr_frame().

encode_frame()

char * LDGM_session::encode_frame ( char * source_data, int frame_size, int * buf_size )

virtual

Method encode should compute parity data for the given source data and add suitable FEC parity header.

Parameters

source_data	Data to encode
frame_size	Size of the frame being encoded
buf_size	Output parameter for storing total size of the returned buffer

Returns

Computed parity data with appropriate FEC parity header

Implements Coding_session.

Definition at line 124 of file ldgm-session.cpp.

{   
    //printf("encode_frame\n");
    Timer_util interval;
    interval.start();
 
    int buf_size;
    int ps;
    short header_size = LDGM_session::HEADER_SIZE;
    int align_coef = param_k*sizeof(int);
 
    if ( (frame_size + header_size) % align_coef == 0 )
        buf_size = frame_size + header_size;
    else
        buf_size = ( ( (frame_size + header_size) / align_coef  ) + 1 ) * align_coef;
 
    ps = buf_size/param_k;
 
    packet_size = ps;
    //printf ( "ps: %d\n", ps );
    buf_size += param_m*ps;
    *out_buf_size = buf_size;
 
    void *out_buf;
    out_buf = alloc_buf(buf_size);
    if (!out_buf)
    {
        printf ( "Unable to allocate memory\n" );
        return NULL;
    }
    memset(out_buf, 0, header_size);
    memset((char*)out_buf + frame_size + header_size, 0, align_coef);
 
    //Insert frame size and copy input data into buffer
 
    int *hdr = (int*)out_buf;
    *hdr = frame_size;
 
    memcpy( ((char*)out_buf) + header_size, frame, frame_size);
 
    //Timer_util t;
    //printf("2buf_size %d\n",buf_size);
    //printf("2packet_size %d\n",packet_size);
    this->encode ( (char*)out_buf, ((char*)out_buf)+param_k*ps );
 
 
    interval.end();
    // printf("time: %e\n",elapsed/1000.0 );
    this->elapsed_sum2 += interval.elapsed_time_ms();
    this->no_frames2++;
 
    return (char*)out_buf;
 
//    printf ( "SSE: %.3lf\n", t.elapsed_time(start, end) );
 
    /*     void *out_buf_check;
     *     error = posix_memalign(&out_buf_check, 16, buf_size);
     *     memset(out_buf_check, 0, buf_size);
     *     hdr = (int*)out_buf_check;
     *     *hdr = frame_size;
     *     memcpy(((char*)out_buf_check)+header_size, frame, frame_size);
     *     clock_gettime(CLOCK_MONOTONIC, &start);
     *     encode_naive ( (char*)out_buf, ((char*)out_buf_check)+param_k*ps );
     *     clock_gettime(CLOCK_MONOTONIC, &end);
     *     printf ( "CPU: %.3lf\n", t.elapsed_time(start, end) );
     *
     *     int e = memcmp(out_buf, out_buf_check, buf_size);
     *     printf ( "memcpy on parities: %d\n", e );
     *     char *a = (char*)out_buf;
     *     char *b = (char*)out_buf_check;
     *     bool equal = true;
     *     int idx = 0;
     *     for ( int i = 0; i < param_m*ps; i++)
     *     {
     *  if(a[i] != b[i])
     *  {
     *      idx = i;
     *      printf ( "Error at index %d: %d vs %d\n", i, (unsigned char)a[i],
     *              (unsigned char)b[i]  );
     *      equal = false;
     *  }
     *     }
     *
     *     printf ( "Parities %s match.\n", (equal)?"":"do not" );
     */
 
//    printf ( "\n\nEncoded block:\n" );
//    printf ( "%-13s\v%10d B\n", "Frame hdr size:", header_size );
//    printf ( "%-13s\v%10d B\n", "Frame size:", frame_size );
//    printf ( "Padding size:\t%-d B\n", buf_size-frame_size-header_size-param_m*ps );
//    printf ( "Parity size:\t%-d B\n", param_m*ps );
//    printf ( "-------------------------------\n");
//    printf ( "Total block size:\t%d B\n", buf_size );
//    printf ( "Symbol size:\t%d\n\n\n", ps );
 
 
 
 
}

References alloc_buf(), elapsed_sum2, Timer_util::elapsed_time_ms(), encode(), Timer_util::end(), frame, HEADER_SIZE, no_frames2, packet_size, param_k, param_m, and Timer_util::start().

Referenced by demo().

Here is the call graph for this function:

encode_hdr_frame()

char * LDGM_session::encode_hdr_frame	(	char *	hdr,
		int	hdr_size,
		char *	frame,
		int	frame_size,
		int *	out_buf_size )

Definition at line 225 of file ldgm-session.cpp.

{
    int buf_size;
    int ps;
    short header_size = LDGM_session::HEADER_SIZE;
    int overall_size = my_hdr_size + frame_size;
    int align_coef = param_k*sizeof(int);
 
    if ( (overall_size + header_size) % align_coef == 0 )
        buf_size = overall_size + header_size;
    else
        buf_size = ( ( (overall_size + header_size) / align_coef  ) + 1 ) * align_coef;
 
    ps = buf_size/param_k;
 
    packet_size = ps;
//    printf ( "ps: %d\n", ps );
    buf_size += param_m*ps;
    *out_buf_size = buf_size;
 
    void *out_buf;
    out_buf = alloc_buf(buf_size);
    if (!out_buf)
    {
        printf ( "Unable to allocate aligned memory\n" );
        return NULL;
    }
    memset(out_buf, 0, buf_size);
 
    //Insert frame size and copy input data into buffer
 
    int32_t *hdr = (int32_t*)out_buf;
    *hdr = overall_size;
 
    memcpy( ((char*)out_buf) + header_size, my_hdr, my_hdr_size);
    memcpy( ((char*)out_buf) + header_size + my_hdr_size, frame, frame_size);
 
#if 0
    int my_frame_size=my_hdr_size+frame_size;
 
    // printf("my_frame_size: %d\n",my_frame_size );
 
    int crc;
    crc = crc32buf((char*)out_buf+header_size,my_frame_size);
 
    memcpy( ((char*)out_buf) + 4, &crc, 4);
    memcpy( ((char*)out_buf) + 8, &my_frame_size, 4);
    assert(LDGM_session::HEADER_SIZE >= 12);
#endif
 
    Timer_util interval;
    interval.start();
 
    this->encode ( (char*)out_buf, ((char*)out_buf)+param_k*ps );
 
    interval.end();
    long elapsed;
 
    elapsed = interval.elapsed_time_us();
    // printf("time: %e\n",elapsed/1000.0 );
    this->elapsed_sum2+=elapsed/1000.0;
    this->no_frames2++;
 
 
    // gettimeofday(&t1,0);
    // long elapsed;
 
    // elapsed = (t1.tv_sec-t0.tv_sec)*1000000 + t1.tv_usec-t0.tv_usec;
    // // printf("time: %e\n",elapsed/1000.0 );
    // this->elapsed_sum2+=elapsed/1000.0;
    // this->no_frames2++;
    // i++;
 
    // if(i%100==0){
    //     printf("TIME GPU: %f ms\n",this->elapsed_sum2/(double)this->no_frames2 );
    //     printf("time: %f ms\n",elapsed/1000.0 );
    // }
 
//    printf ( "SSE: %.3lf\n", t.elapsed_time(start, end) );
 
    /*     void *out_buf_check;
     *     error = posix_memalign(&out_buf_check, 16, buf_size);
     *     memset(out_buf_check, 0, buf_size);
     *     hdr = (int*)out_buf_check;
     *     *hdr = frame_size;
     *     memcpy(((char*)out_buf_check)+header_size, frame, frame_size);
     *     clock_gettime(CLOCK_MONOTONIC, &start);
     *     encode_naive ( (char*)out_buf, ((char*)out_buf_check)+param_k*ps );
     *     clock_gettime(CLOCK_MONOTONIC, &end);
     *     printf ( "CPU: %.3lf\n", t.elapsed_time(start, end) );
     *
     *     int e = memcmp(out_buf, out_buf_check, buf_size);
     *     printf ( "memcpy on parities: %d\n", e );
     *     char *a = (char*)out_buf;
     *     char *b = (char*)out_buf_check;
     *     bool equal = true;
     *     int idx = 0;
     *     for ( int i = 0; i < param_m*ps; i++)
     *     {
     *  if(a[i] != b[i])
     *  {
     *      idx = i;
     *      printf ( "Error at index %d: %d vs %d\n", i, (unsigned char)a[i],
     *              (unsigned char)b[i]  );
     *      equal = false;
     *  }
     *     }
     *
     *     printf ( "Parities %s match.\n", (equal)?"":"do not" );
     */
 
//    printf ( "\n\nEncoded block:\n" );
//    printf ( "%-13s\v%10d B\n", "Frame hdr size:", header_size );
//    printf ( "%-13s\v%10d B\n", "Frame size:", frame_size );
//    printf ( "Padding size:\t%-d B\n", buf_size-frame_size-header_size-param_m*ps );
//    printf ( "Parity size:\t%-d B\n", param_m*ps );
//    printf ( "-------------------------------\n");
//    printf ( "Total block size:\t%d B\n", buf_size );
//    printf ( "Symbol size:\t%d\n\n\n", ps );
 
 
    return (char*)out_buf;
 
}

References alloc_buf(), crc32buf(), elapsed_sum2, Timer_util::elapsed_time_us(), encode(), Timer_util::end(), frame, HEADER_SIZE, no_frames2, packet_size, param_k, param_m, and Timer_util::start().

Here is the call graph for this function:

encode_naive()

virtual void LDGM_session::encode_naive ( char * data, char * parity )

pure virtual

Implemented in LDGM_session_cpu, and LDGM_session_gpu.

free_out_buf()

virtual void LDGM_session::free_out_buf ( char * buf )

pure virtual

Implemented in LDGM_session_cpu, and LDGM_session_gpu.

get_packet_size()

unsigned int LDGM_session::get_packet_size ( ) const

inline

Definition at line 59 of file ldgm-session.h.

            {
                return packet_size;
            }

References packet_size.

Referenced by LDGM_session_gpu::encode().

needs_decoding()

bool LDGM_session::needs_decoding

(

Tanner_graph *

tanner_graph

)

This method checks whether the given graph needs further decoding

Parameters

tanner_graph

Given Tanner graph

Returns

true if the given graph needs decoding, false otherwise

Definition at line 400 of file ldgm-session.cpp.

{
    for ( int i = 0; i < param_k; i++)
        if( ! graph->nodes.at(i).isDone() ) {
            return true;
        }
    return false;
}               /*  -----  end of method LDGM_session::needs_decoding  ----- */

References Tanner_graph::nodes, and param_k.

Referenced by LDGM_session_cpu::decode_frame().

set_params()

void LDGM_session::set_params ( unsigned short k, unsigned short m, unsigned short rw )

inline

Definition at line 92 of file ldgm-session.h.

            {
                param_k = k;
                param_m = m;
                row_weight = rw;
            }

References param_k, param_m, and row_weight.

Referenced by demo().

set_pcMatrix()

void LDGM_session::set_pcMatrix

(

char *

matrix

)

Definition at line 40 of file ldgm-session.cpp.

{
    FILE *f;
 
    f = fopen(fname, "rb");
    if (!f)
    {
        printf ( "Error opening matrix file\n" );
        printf ( "exiting\n" );
        abort();
    }
    unsigned int k_f, m_f, w_f;
    if (fscanf(f, "%d %d %d", &k_f, &m_f, &w_f) != 3) {
        throw string("Parity matrix read error!");
    }
//    printf ( "In matrix file: K %d M %d Columns %d\n", k_f, m_f, w_f );
 
    if (w_f < 2 || w_f > MAX_W) {
        throw string("Invalid parameter in parity matrix (allowed range [2.." + to_string(MAX_W) + "])!");
    }
 
    if ( k_f != param_k || m_f != param_m)
    {
        ostringstream oss;
        oss << "Parity matrix size mismatch\nExpected K = " << param_k << "% M = " << param_m <<
                "\nReceived K = " << k_f << ", M = " << m_f << "\n";
        throw oss.str();
    }
    if (fseek (f, 1, SEEK_CUR ) != 0) {
            perror("fseek");
    }
 
    pcm = (int*) malloc(w_f*param_m*sizeof(int));
    for ( int i = 0; i < (int)w_f*param_m; i++) {
        if (fread ( pcm+i, sizeof(int), 1, f) != 1) {
            throw string("Parity matrix read error!");
        }
    }
    this->max_row_weight = w_f - 2; //w_f stores number of columns in adjacency list
 
    /*     for ( int i = 0; i < param_m; i++)
     *     {
     *  for ( int j = 0; j < w_f; j++)
     *      printf ( "[%3d]", (unsigned int)(pcm[i*w_f+j]) );
     *  printf ( "\n" );
     *     }
     */
 
 
 
 
    fclose(f);
 
 
 
    /*
     *     this->max_row_weight = 0;
     *     int max_weight = 0;
     *     for ( int i = 0; i < param_m; ++i) {
     *  for ( int j = 0; j < param_k; ++j) {
     *      if(*(matrix + i*param_k + j) == 1) {
     *          *(pcMatrix + i*param_k + j) = *(matrix + i*param_k + j);
     *          max_weight++;
     *      }
     *  }
     *  if ( max_weight > this->max_row_weight )
     *      this->max_row_weight = max_weight;
     *  max_weight = 0;
     *     }
     *
     *     pcm = (int*) malloc (m*(max_row_weight+2)*sizeof(int*));
     *     struct coding_params params;
     *     params.m = m;
     *     params.k = k;
     *     params.max_row_weight = max_row_weight;
     *
     *     make_compact_pcm ( matrix, pcm, params);
     */
 
 
    return ;
}               /*  -----  end of method Coding_session::set_pcMatrix  ----- */

References max_row_weight, MAX_W, param_k, param_m, and pcm.

Referenced by demo().

Member Data Documentation

elapsed_sum2

double LDGM_session::elapsed_sum2

protected

Definition at line 121 of file ldgm-session.h.

Referenced by LDGM_session_cpu::~LDGM_session_cpu(), LDGM_session_gpu::~LDGM_session_gpu(), LDGM_session_cpu::decode_frame(), LDGM_session_gpu::decode_frame(), encode_frame(), and encode_hdr_frame().

HEADER_SIZE

const int LDGM_session::HEADER_SIZE = 4

staticprotected

Definition at line 124 of file ldgm-session.h.

Referenced by LDGM_session_cpu::decode_frame(), LDGM_session_gpu::decode_frame(), encode_frame(), and encode_hdr_frame().

lost_ptr

char* LDGM_session::lost_ptr

protected

Definition at line 119 of file ldgm-session.h.

max_row_weight

unsigned short LDGM_session::max_row_weight

protected

Definition at line 116 of file ldgm-session.h.

Referenced by create_edges(), LDGM_session_gpu::decode_frame(), LDGM_session_cpu::encode(), LDGM_session_gpu::encode(), LDGM_session_cpu::encode_naive(), and set_pcMatrix().

no_frames2

long LDGM_session::no_frames2

protected

Definition at line 122 of file ldgm-session.h.

Referenced by LDGM_session_cpu::~LDGM_session_cpu(), LDGM_session_gpu::~LDGM_session_gpu(), LDGM_session_cpu::decode_frame(), LDGM_session_gpu::decode_frame(), encode_frame(), and encode_hdr_frame().

packet_size

unsigned short LDGM_session::packet_size

protected

Definition at line 115 of file ldgm-session.h.

Referenced by LDGM_session_cpu::decode_frame(), LDGM_session_cpu::encode(), LDGM_session_gpu::encode(), encode_frame(), encode_hdr_frame(), LDGM_session_cpu::encode_naive(), get_packet_size(), and LDGM_session_cpu::iterate().

param_k

unsigned short LDGM_session::param_k

protected

Definition at line 112 of file ldgm-session.h.

Referenced by create_edges(), LDGM_session_cpu::decode_frame(), LDGM_session_gpu::decode_frame(), LDGM_session_cpu::encode(), LDGM_session_gpu::encode(), encode_frame(), encode_hdr_frame(), LDGM_session_cpu::encode_naive(), LDGM_session_cpu::iterate(), needs_decoding(), set_params(), and set_pcMatrix().

param_m

unsigned short LDGM_session::param_m

protected

Definition at line 113 of file ldgm-session.h.

Referenced by create_edges(), LDGM_session_cpu::decode_frame(), LDGM_session_gpu::decode_frame(), LDGM_session_cpu::encode(), LDGM_session_gpu::encode(), encode_frame(), encode_hdr_frame(), LDGM_session_cpu::encode_naive(), LDGM_session_cpu::iterate(), set_params(), and set_pcMatrix().

pcm

int* LDGM_session::pcm

protected

Definition at line 110 of file ldgm-session.h.

Referenced by ~LDGM_session(), create_edges(), LDGM_session_gpu::decode_frame(), LDGM_session_cpu::encode(), LDGM_session_gpu::encode(), LDGM_session_cpu::encode_naive(), and set_pcMatrix().

pcMatrix

char* LDGM_session::pcMatrix

protected

Definition at line 109 of file ldgm-session.h.

received_ptr

char* LDGM_session::received_ptr

protected

Definition at line 118 of file ldgm-session.h.

row_weight

unsigned short LDGM_session::row_weight

protected

Definition at line 114 of file ldgm-session.h.

Referenced by set_params().

---

The documentation for this class was generated from the following files:

• ldgm/src/ldgm-session.h
• ldgm/src/ldgm-session.cpp