LDGM_session_cpu Class Reference

#include <ldgm-session-cpu.h>

Inheritance diagram for LDGM_session_cpu:

Collaboration diagram for LDGM_session_cpu:

Public Member Functions
	LDGM_session_cpu ()
	~LDGM_session_cpu ()
void *	alloc_buf (int size)
char *	decode_frame (char *received_data, int buf_size, int *frame_size, std::map< int, int > valid_data)
void	encode (char *, char *)
void	encode_naive (char *, char *)
void	free_out_buf (char *buf)
void	iterate (Tanner_graph *graph)
Public Member Functions inherited from LDGM_session
	LDGM_session ()
virtual	~LDGM_session ()
void	create_edges (Tanner_graph *g)
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)
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

Private Attributes
double	elapsed_sum
long	no_frames

Additional Inherited Members
Protected Attributes inherited from LDGM_session
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 inherited from LDGM_session
static const int	HEADER_SIZE = 4

Detailed Description

Definition at line 32 of file ldgm-session-cpu.h.

Constructor & Destructor Documentation

LDGM_session_cpu()

LDGM_session_cpu::LDGM_session_cpu ( )

inline

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

                            {
                printf("CPU LDGM in progress .... \n");
                elapsed_sum=0.0;
                no_frames=0;
        }                            /* constructor */

References elapsed_sum, and no_frames.

~LDGM_session_cpu()

LDGM_session_cpu::~LDGM_session_cpu ( )

inline

Definition at line 41 of file ldgm-session-cpu.h.

                             {
                printf("LDGM TIME CPU: %f ms\n",this->elapsed_sum2/(double)this->no_frames2 );
         }                            /* constructor */

References LDGM_session::elapsed_sum2, and LDGM_session::no_frames2.

Member Function Documentation

alloc_buf()

void * LDGM_session_cpu::alloc_buf ( int size )

virtual

Implements LDGM_session.

Definition at line 139 of file ldgm-session-cpu.cpp.

{
    void *out_buf = aligned_malloc(buf_size, 16);
    if (!out_buf)
    {
        printf ( "Unable to allocate aligned memory\n" );
 
    }
    return out_buf;
 
}

References aligned_malloc().

Here is the call graph for this function:

decode_frame()

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

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 LDGM_session.

Definition at line 247 of file ldgm-session-cpu.cpp.

{
//    printf ( "buf_size: %d\n", buf_size );
 
    Timer_util interval;
    interval.start();
 
 
    Tanner_graph graph;
 
    int p_size = buf_size/(param_m+param_k);
    this->packet_size = p_size;
//    printf ( "p_size %d\n", p_size );
    graph.set_data_size(p_size);
 
    //Timer_util timer;
 
    int i;
    int index = 0;
 
 
//    while ( i < (param_k + param_m)*p_size)
//    {
//      printf ( "%2d|", (unsigned char)received[i++] );
//    }
 
    //one variable node per each data packet in block K
    for ( i = 0; i < param_k; ++i )
        graph.add_node(Node::variable_node, index++, received + i*p_size);
 
    //one variable node per each parity packet in block M
    for ( i = 0; i < param_m; ++i)
        graph.add_node(Node::variable_node, index++, received + (i + param_k)*p_size);
 
    //one constraint node per each row of generation matrix
    for ( i = 0; i < param_m; ++i)
        graph.add_node(Node::constraint_node, index++, NULL);
 
    create_edges(&graph);
 
//    printf("Graph created in: %.3f s\n", t);
 
    /*      printf ( "graf\n" );
     *     for(map<int, Node>::iterator it = graph.nodes.begin(); it != graph.nodes.end(); ++it) {
     *      Node n = it->second;
     *      for ( int i = 0; i < p_size; ++i)
     *          printf("%2d|", *(unsigned char *)(n.getDataPtr() + i));
     *      printf ( "---\n" );
     *      }
     */
 
    /*      for(map<int, Node>::iterator it = graph.nodes.begin(); it != graph.nodes.end(); ++it) {
     *      Node n = it->second;
     *      printf ( "neigbours of %d (count %lu): ", it->first, (it->second).neighbours.size() );
     *      for(vector<int>::iterator itr = n.neighbours.begin(); itr != n.neighbours.end(); ++itr)
     *          printf ( "%d ", *itr );
     *      printf ( "\n" );
     *     }
     */
 
    //We need to merge intervals in the valid data vector
    map <int, int> merged_intervals;
    map<int,int>::iterator map_it;
 
    if ( valid_data.size() != 0 )
    {
        for ( map_it = valid_data.begin(); map_it != valid_data.end(); )
        {
            int start = map_it->first;
            int length = map_it->second;
            while ( start + length == (++map_it)->first )
                length += map_it->second;
            merged_intervals.insert ( pair<int, int> (start, length) );
        }
    }
    /*     printf ( "Valid data: \n" );
     *     for ( map_it = valid_data.begin(); map_it != valid_data.end(); ++map_it)
     *     {
     *  printf ( "|%d-%d| ", map_it->first, map_it->second );
     *     }
     *     printf ( "\n" );
     *
     *     printf ( "Merged intervals: \n" );
     *     for ( map_it = merged_intervals.begin(); map_it != merged_intervals.end(); ++map_it)
     *     {
     *  printf ( "|%d-%d| ", map_it->first, map_it->second );
     *     }
     *     printf ( "\n" );
     *
     */
 
 
 
    map<int, Node>::iterator it;
    if ( merged_intervals.size() != 0)
    {
        it = graph.nodes.find(0);
        const auto variable_node_end_it = graph.nodes.find(param_k+param_m); // == 1st constraint node
        assert(variable_node_end_it != graph.nodes.end());
        while (it != variable_node_end_it) {
            (*it).second.setDone(false);
            int node_offset = (*it).second.getDataPtr() - received;
//          printf ( "offset: %d\n", node_offset );
 
            map_it = merged_intervals.begin();
            //Find the offset in valid data which is equal, or the first offset which is
            //lower than node offset
            bool found = false;
            while ( (map_it->first <= node_offset) && map_it != merged_intervals.end() )
            {
                map_it++;
                found = true;
            }
            if ( found )
                map_it--;
 
            //Next, find out if some interval covers this symbol
            if ( found && (map_it->first + map_it->second) >=
                    (node_offset + p_size) )
            {
                (*it).second.setDone(true);
//              printf ( "setting node %d with offset %d and size %d as done\n", it->first,
//                      node_offset, p_size);
            }
 
            ++it;
        }
    }
 
    //int not_done = 0;
    for ( it = graph.nodes.begin(); it != graph.nodes.find(param_k); it++)
    {
        if ( !it->second.isDone())
        {
            memset(it->second.getDataPtr(), 0, p_size);
//          printf ( "resetting node: %d\n", it->first );
            //not_done++;
        }
    }
//    printf ( "not done: %d\n", not_done );
    /*     srand(time(NULL));
     *     for ( int j = 0; j < 100; j++)
     *     {
     *  it = graph.nodes.find(rand()%(param_k+param_m));
     *  (*it).second.setDone(false);
     *     }
     */
    int iter = 0;
 
    while ( needs_decoding(&graph) && iter < 4) {
//      printf ( "iteratin\n" );
        iterate(&graph);
        iter++;
    }
 
//    printf("decoding process: %.3f s\n", t);
 
    //printf ( "iterations: %d\n", iter );
 
    int undecoded = 0;
    it = graph.nodes.find(0);
    while ( it != graph.nodes.find(param_k) ) {
        if (!(*it).second.isDone())
            undecoded++;
        ++it;
    }
//    printf ( "Number of not recovered data packets: %d\n", undecoded );
 
    //    printf("rest: %.3f s\n", t);
 
    if ( undecoded == 0 )
    {
        union int_bytes {
            unsigned int number;
            unsigned char bytes[4];
        };
        union int_bytes fs;
        memcpy(&(fs.bytes), received, 4);
        *frame_size = fs.number;
    }
    else
        *frame_size = 0;
 
 
    interval.end();
    //printf("time: %e\n",elapsed/1000.0 );
    this->elapsed_sum2 += interval.elapsed_time_ms();
    this->no_frames2++;
 
    if(this->no_frames==150){
        //printf("TIME: %f ms\n",this->elapsed_sum/(double)this->no_frames );
    }
 
    return received + LDGM_session::HEADER_SIZE;
}               /* -----  end ofmethod LDGM_session_cpu::decode  ----- */

References Tanner_graph::add_node(), Node::constraint_node, LDGM_session::create_edges(), LDGM_session::elapsed_sum2, Timer_util::elapsed_time_ms(), Timer_util::end(), first, LDGM_session::HEADER_SIZE, iterate(), LDGM_session::needs_decoding(), no_frames, LDGM_session::no_frames2, Tanner_graph::nodes, LDGM_session::packet_size, LDGM_session::param_k, LDGM_session::param_m, Tanner_graph::set_data_size(), start(), Timer_util::start(), and Node::variable_node.

Referenced by demo().

Here is the call graph for this function:

encode()

void LDGM_session_cpu::encode ( char * data_ptr, char * parity_ptr )

virtual

Implements LDGM_session.

Definition at line 152 of file ldgm-session-cpu.cpp.

{
//    start encoding
   // printf ( "packet_size: %d\n", this->packet_size );
 
    char *parity_packet;
 
        parity_packet = (char *) aligned_malloc(packet_size, 16);
        if (!parity_packet)
        {
                printf ( "Error while using posix_memalign\n" );
                return;
        }
        memset(parity_packet, 0, packet_size);
 
    for ( int m = 0; m < param_m; ++m) {
//      printf ( "m: %d\n", m );
 
//      printf ( "max w: %d\n", max_row_weight );
        //Find out which packets to XOR
        for ( int k = 0; k < max_row_weight+2; ++k) {
            int idx = pcm[m*(max_row_weight+2) + k];
//          printf ( "adept: %d\n", idx );
            if (idx > -1 && idx < param_k) {
//              printf ( "xoring idx: %d\n", idx );
                char *ptr = data_ptr + idx*packet_size;
                parity_packet = xor_using_sse(ptr, parity_packet, packet_size);
            }
        }
 
        //Add the new parity packet to overall parity
        memcpy ( parity_ptr + m*packet_size, parity_packet, packet_size );
    }
 
        aligned_free(parity_packet);
 
    return ;
}               /* -----  end of method LDGM_session_cpu::encode  ----- */

References aligned_free, aligned_malloc(), LDGM_session::max_row_weight, LDGM_session::packet_size, LDGM_session::param_k, LDGM_session::param_m, LDGM_session::pcm, and xor_using_sse().

Here is the call graph for this function:

encode_naive()

void LDGM_session_cpu::encode_naive ( char * data_ptr, char * parity_ptr )

virtual

Implements LDGM_session.

Definition at line 198 of file ldgm-session-cpu.cpp.

{
//    start encoding
 
    void *ppacket;
    char *parity_packet;
 
    for ( int m = 0; m < param_m; ++m) {
 
        ppacket = aligned_malloc(packet_size, 16);
        if (!ppacket)
        {
            printf ( "Error while using posix_memalign\n" );
            return;
        }
        memset(ppacket, 0, packet_size);
        parity_packet = (char*)ppacket;
 
        //Find out which packets to XOR
        for ( int k = 0; k < max_row_weight+2; ++k) {
            int idx = pcm[m*(max_row_weight+2) + k];
            if (idx > -1 && idx < param_k) {
                char *ptr = data_ptr + idx*packet_size;
//              parity_packet = xor_using_sse(ptr, parity_packet, packet_size);
                for ( int i = 0; i < packet_size; i++)
                    parity_packet[i] ^= *(ptr+i);
            }
        }
 
        //Apply inverted staircase matrix
        if( m > 0) {
            char *prev_parity = parity_ptr + (m-1)*packet_size;
//          parity_packet = xor_using_sse(prev_parity, parity_packet, packet_size);
            for ( int i = 0; i < packet_size; i++)
                parity_packet[i] ^= *(prev_parity+i);
        }
 
 
        //Add the new parity packet to overall parity
        memcpy ( parity_ptr + m*packet_size, parity_packet, packet_size );
        aligned_free(ppacket);
 
    }
    return ;
}               /* -----  end of method LDGM_session_cpu::encode  ----- */

References aligned_free, aligned_malloc(), LDGM_session::max_row_weight, LDGM_session::packet_size, LDGM_session::param_k, LDGM_session::param_m, and LDGM_session::pcm.

Here is the call graph for this function:

free_out_buf()

void LDGM_session_cpu::free_out_buf ( char * buf )

virtual

Implements LDGM_session.

Definition at line 192 of file ldgm-session-cpu.cpp.

{
    if ( buf != NULL )
        aligned_free(buf);
}

References aligned_free.

Referenced by demo().

iterate()

void LDGM_session_cpu::iterate

(

Tanner_graph *

graph

)

Definition at line 446 of file ldgm-session-cpu.cpp.

{
    map<int, Node>::iterator it_c;
    vector<int> vec;
 
    //static int recovered = 0;
 
    //select the first constraint node
    it_c = graph->nodes.find ( param_k + param_m );
 
    //iterate through constraint nodes
    while ( it_c != graph->nodes.end() ) {
        //iterate the node's neighbours to find out how many of them are not decoded
        for(vector<int>::iterator j = it_c->second.neighbours.begin();
                j != it_c->second.neighbours.end(); ++j) {
            const auto it_v = graph->nodes.find(*j);
            if ( !it_v->second.isDone() )
                vec.push_back(*j);
        }
//      printf ( "node %d has %d undecoded neighbours\n", it_c->first, vec.size() );
 
        //we can restore the missing packet
        if ( vec.size() == 1)
        {
            int r_index = vec.front();
 
//          if ( r_index == 0 )
//          {
//              printf ( "repairing first block\n" );
//          }
            auto &node = graph->nodes.at(r_index);
            memset(node.getDataPtr(), 0, packet_size);
            char *r_data = node.getDataPtr();
            //find other nodes connected to this constraint node and XOR their values
            int count = 0;
            for(vector<int>::iterator j = it_c->second.neighbours.begin();
                    j != it_c->second.neighbours.end(); ++j)
            {
                if ( *j != r_index )
                {
//                  printf ( "decode, packet_size: %d\n", packet_size );
                    char *g_data = (graph->nodes.find(*j))->second.getDataPtr();
                    //XOR
                    xor_using_sse(g_data, r_data, packet_size);
                    count++;
                }
            }
            /*           //validate recovered packet
             *          for ( int i = 0; i < param_k; ++i) {
             *              if(!memcmp(r_data, lost_ptr + i*packet_size, packet_size)) {
             *                  printf ( "packet ok\n" );
             *                  break;
             *              }
             *          }
             */
            if ( count > 0 )
                node.setDone(true);
            //recovered++;
            /*           printf ( "restored data: \n" );
             *          for ( int  i = 0; i < packet_size; ++i)
             *              printf ( "%2d|", (unsigned char)(*(it_v->second.getDataPtr() + i)) );
             *          printf ( "---\n" );
             */
 
 
        }
        vec.clear();
 
        ++it_c;
    }
//    printf ( "recovered: %d\n", recovered );
 
    return;
 
}

References count, Tanner_graph::nodes, LDGM_session::packet_size, LDGM_session::param_k, LDGM_session::param_m, and xor_using_sse().

Referenced by decode_frame().

Here is the call graph for this function:

Member Data Documentation

elapsed_sum

double LDGM_session_cpu::elapsed_sum

private

Definition at line 69 of file ldgm-session-cpu.h.

Referenced by LDGM_session_cpu().

no_frames

long LDGM_session_cpu::no_frames

private

Definition at line 70 of file ldgm-session-cpu.h.

Referenced by LDGM_session_cpu(), and decode_frame().

---

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

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