main.cpp File Reference

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <set>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <iostream>
#include <fstream>
#include "ldgm-session-cpu.h"
#include "ldgm-session-gpu.h"
#include "timer-util.h"

Include dependency graph for main.cpp:

Go to the source code of this file.

Macros
#define	COLUMN_WEIGHT   3 /* Number of 1's in a columns of parity matrix */
#define	ITERATIONS   100
#define	PACKET_LOSS   0.08 /* Packet loss rate */
#define	ROW_WEIGHT   3 /* Number of 1's in a row of parity matrix */

Functions
void	compare_int_arrays (int *a, int *b, int size)
int	demo (int m, int k, int frame_size, char *matrix_fname, char *data_fname, int cpu, int gpu)
void	demo_gpu ()
void	fillParityMatrix (char **matrix, int height, int width)
int	main (int argc, char *argv[])
void	printData (char *data, int count, int packet_size)
void	printMatrix (char **m, int height, int width)
void	usage ()

Macro Definition Documentation

COLUMN_WEIGHT

#define COLUMN_WEIGHT   3 /* Number of 1's in a columns of parity matrix */

Definition at line 39 of file main.cpp.

Referenced by demo().

ITERATIONS

#define ITERATIONS   100

Definition at line 42 of file main.cpp.

Referenced by demo().

PACKET_LOSS

#define PACKET_LOSS   0.08 /* Packet loss rate */

Definition at line 41 of file main.cpp.

Referenced by demo().

ROW_WEIGHT

#define ROW_WEIGHT   3 /* Number of 1's in a row of parity matrix */

Definition at line 38 of file main.cpp.

Function Documentation

compare_int_arrays()

void compare_int_arrays	(	int *	a,
		int *	b,
		int	size )

Definition at line 140 of file main.cpp.

{
    bool equal = true;
    int idx = -1;
    for ( int i = 0; i < size; i++ )
    {
        if ( a[i] != b[i] )
        {
            equal = false;
            idx = i;
            printf ( "p1: %d, p2: %d\n", a[i], b[i] );
            break;
//          printf ( "Difference at integer position: %d\n", idx );
//          printf ( "Difference at packet position: %d\n", idx/2048 );
        }
    }
    printf ( "Arrays are %s.\n", (equal)?"equal":"not equal" );
 
}

demo()

int demo	(	int	m,
		int	k,
		int	frame_size,
		char *	matrix_fname,
		char *	data_fname,
		int	cpu,
		int	gpu )

Definition at line 166 of file main.cpp.

{
    Timer_util t;
 
//    LDGM_session_gpu* coding_session_gpu = new LDGM_session_gpu();
    LDGM_session_cpu* coding_session_cpu = new LDGM_session_cpu();
    LDGM_session_cpu* coding_session_cpu_2 = new LDGM_session_cpu();
 
  //  coding_session_gpu->set_params ( k, m, COLUMN_WEIGHT);
    coding_session_cpu->set_params ( k, m, COLUMN_WEIGHT);
    coding_session_cpu_2->set_params ( k, m, COLUMN_WEIGHT);
    //coding_session_gpu->set_data_fname(data_fname);
 
    coding_session_cpu->set_pcMatrix ( matrix_fname);
    coding_session_cpu_2->set_pcMatrix ( matrix_fname);
    //coding_session_gpu->set_pcMatrix ( matrix_fname);
 
    //generate data
    void *data;
    
    //allocate memory with address aligned to 16 bytes
    int e = posix_memalign(&data, 16, frame_size);
 
    if ( e != 0 ) {
        fprintf ( stderr, "Unable to allocate memory using posix_memalign.\n");
        return EXIT_FAILURE;
    }
 
    for ( int i = 0; i < frame_size; ++i)
        memset((char*)data+i, rand() % 256, 1);
 
    //alocate space for parity packets
 
//    void *parity;
    //allocate memory with address aligned to 16 bytes
//    e = posix_memalign(&parity, 16, (size_t)m*packet_size);
//    
//    if ( e != 0 ) {
//      fprintf ( stderr, "Unable to allocate memory using posix_memalign.\n");
//      return EXIT_FAILURE;
//    }
 
 
//    coding_session->add_src_head ( (char*) data, src_block, (uint16_t)0);
 
     //print first K data packets
//    printData ( (char*) data, K, PACKET_SIZE);
//    printData ( (char*) parity, M, PACKET_SIZE);
//    void *parity2;
    //allocate memory with address aligned to 16 bytes
//    e = posix_memalign(&parity2, 16, (size_t)m*packet_size);
    
//    if ( e != 0 ) {
//      fprintf ( stderr, "Unable to allocate memory using posix_memalign.\n");
//      return EXIT_FAILURE;
//    }
 
//    printf ( "k %d m %d frame_size %d, matrix %s data %s cpu %d gpu %d\n", 
//          k, m, frame_size, matrix_fname, data_fname, cpu, gpu);
 
//   char *output = coding_session_cpu->encode_frame( (char*) data, packet_size);
 
 
    char* output;
    int buf_size;
    int f_size;
    char *decoded;
    map<int, int>  valid_data;
    int ps;
    srand(time(NULL));
    if (cpu)
    {
        t.start();
 
        for ( int i = 0; i < ITERATIONS; i++)
        {
                printf ( "encoding\n" );
                output = coding_session_cpu->encode_frame ( (char*) data, frame_size, &buf_size );
                ps = 1392; // coding_session_cpu->get_packet_size();
                int total = 0;
 
                valid_data.clear();
 
                for ( int j = 0; j < buf_size ; j += ps) {
                        int size = ps;
                        if(j + ps > buf_size) {
                                size = buf_size - j;
                        }
                        if(rand() % 100 > PACKET_LOSS * 100 ) {
                                valid_data.insert(pair<int,int>(j, size));
                                total += size;
                        } else {
                                if(j == 0) {
                                        fprintf(stderr, "Dropping first packet!!!!!!!!!!!!\n");
                                }
                                memset(output + j, 0x0, size);
                        }
                }
 
                int c;
                printf ( "received bytes: %d\n", total );
                printf ( "decoding\n" );
                decoded = coding_session_cpu_2->decode_frame(output, buf_size, &f_size, valid_data);
                printf ( "f_size: %d\n", f_size );
                static int good = 0;
                static int bad = 0;
                if(f_size) good++; else bad++;
                fprintf(stderr, "good: %d bad: %d\n", good, bad);
 
                for (int x= 0; x < f_size; ++x) {
                        if(((char *)data)[x] != decoded[x]) {
                                fprintf(stderr, "Different character %d / %d (original size %d)\n", x, f_size, frame_size);
                                break;
                        }
                }
                //memset(decoded, 0, f_size);
                coding_session_cpu->free_out_buf(output);
        }
        t.end();
        //      printf ( "CPU encoded in: %.6lf\n", t.elapsed_time(start, end) );
    } 
    if (gpu)
    {
            t.start();
 
            for ( int i = 0; i < ITERATIONS; i++)
                    //      coding_session_gpu->encode ( (char*) data, (char*) frame_size );
 
                    t.end();
            printf ( "GPU encoded in: %.6lf\n", t.elapsed_time() );
    }
 
 
#if 0
    ofstream out;
    out.open(data_fname, ios::out | ios::app);
 
    out << t.elapsed_time() << ",";
 
    out.close();
 
    union int_bytes {                                                                               
            unsigned int number;                                                                        
            unsigned char bytes[4];                                                                     
    };                                                                                              
    union int_bytes fs;
    memcpy(&(fs.bytes), output, 4);
 
    //    printf ( "frame_size: \t\t%d\n", fs.number );
    //    printf ( "packet_size: \t\t%d\n", coding_session_cpu->get_packet_size() );
 
 
    //    printData ( (char*) output, 5, coding_session_cpu->get_packet_size());
 
 
    coding_session_cpu->free_out_buf(output);
#endif
    delete coding_session_cpu;
    delete coding_session_cpu_2;
    //    delete coding_session_gpu;
    free ( data );
 
    return EXIT_SUCCESS;
}

References COLUMN_WEIGHT, LDGM_session_cpu::decode_frame(), Timer_util::elapsed_time(), LDGM_session::encode_frame(), Timer_util::end(), LDGM_session_cpu::free_out_buf(), ITERATIONS, PACKET_LOSS, LDGM_session::set_params(), LDGM_session::set_pcMatrix(), and Timer_util::start().

Referenced by main().

Here is the call graph for this function:

demo_gpu()

void demo_gpu

(

)

fillParityMatrix()

void fillParityMatrix	(	char **	matrix,
		int	height,
		int	width )

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 57 of file main.cpp.

{
    short m, k, column_weight;
    int frame_size;
 
    opterr = 0;
    int c;
    int gpu = 0;
    int cpu = 0;
    char fname[32];
    char matrix_fname[32];
 
    while ( ( c = getopt ( argc, argv, "cf:gk:m:o:t:w:")) != -1 ) {
        switch(c) {
            case 'w':
                column_weight = atoi ( optarg );
                break;
            case 'c':
                if(gpu)
                {
                    fprintf (stderr,  "Only one of the options 'c' 'g' can be chosen.\n" );
                    return EXIT_FAILURE;
                }
                cpu = 1;
                break;
            case 'f':
                frame_size = atoi ( optarg );
                break;
            case 'g':
                if(cpu)
                {
                    fprintf (stderr,  "Only one of the options 'c' 'g' can be chosen.\n" );
                    return EXIT_FAILURE;
                }
                gpu = 1;
                break;
            case 'k':
                k = atoi ( optarg );
                break;
            case 'm':
                m = atoi ( optarg );
                break;
            case 'o':
                sprintf(fname, optarg, 32);
                break;
            case 't':
                sprintf(matrix_fname, optarg, 32);
                break;
            case '?':
                if ( optopt == 'c' || optopt == 'k' || optopt == 'm' )
                    fprintf ( stderr, "Option -%c requires an argument.\n", optopt);
                else if ( isprint ( optopt))
                    fprintf ( stderr, "Unknown option '-%c'.\n", optopt);
                else
                    fprintf ( stderr, "Uknown option character '\\x%x'.\n", optopt);
 
                return 1;
            default:
                abort();
        }
    }
 
    demo( k, m, frame_size, matrix_fname, fname, cpu, gpu);
 
    //    demo_gpu();
 
    return EXIT_SUCCESS;
}       /* ----------  end of function main  ---------- */

References demo().

Here is the call graph for this function:

printData()

void printData	(	char *	data,
		int	count,
		int	packet_size )

Definition at line 339 of file main.cpp.

{
        for ( int k = 0; k < count ; ++k) {
                for ( int i = 0; i < packet_size; ++i )
                        printf ( "%d|", *((unsigned char*)(data) + k*packet_size + i ));
                printf ( "---\n" );
        }
}

References count.

printMatrix()

void printMatrix	(	char **	m,
		int	height,
		int	width )

Definition at line 354 of file main.cpp.

{
        for(int i = 0; i < height; ++i) {
                for(int j = 0; j < width; ++j) {
                        printf("%3d", (unsigned char)m[i][j]);
                }
                printf("\n");
        }
        return;
}               /*  -----  end of function printMatrix  ----- */

usage()

void usage

(

void

)

Definition at line 134 of file main.cpp.

{
    printf ( "\nUsage:\n" );
 
}