LDGM_session_gpu Class Reference

#include <ldgm-session-gpu.h>

Inheritance diagram for LDGM_session_gpu:

Collaboration diagram for LDGM_session_gpu:

Public Member Functions
	LDGM_session_gpu ()
	LDGM_session_gpu (const LDGM_session_gpu &other)
	~LDGM_session_gpu ()
void *	alloc_buf (int size)
void	decode ()
char *	decode_frame (char *received_data, int buf_size, int *frame_size, std::map< int, int > valid_data)
void	encode (char *data_ptr, char *parity_ptr)
void	encode_naive (char *, char *)
void	free_out_buf (char *buf)
void	set_data_fname (char fname[32])
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
std::map< char *, size_t >	bufferSizes
char	data_fname [32]
int *	ERROR_VEC
int *	error_vec
std::queue< char * >	freeBuffers
int *	OUTBUF
int	OUTBUF_SIZE
int *	PCM
int *	SYNC_VEC
int *	sync_vec

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 35 of file ldgm-session-gpu.h.

Constructor & Destructor Documentation

LDGM_session_gpu() [1/2]

LDGM_session_gpu::LDGM_session_gpu

(

)

Definition at line 45 of file ldgm-session-gpu.cpp.

                                   {
    printf("GPU LDGM in progress .... \n");
 
    error_vec=NULL;
    sync_vec=NULL;
 
    ERROR_VEC=NULL;
    SYNC_VEC=NULL;
 
    PCM=NULL;
 
    OUTBUF_SIZE=0;
    OUTBUF=NULL;
}

References ERROR_VEC, error_vec, OUTBUF, OUTBUF_SIZE, PCM, SYNC_VEC, and sync_vec.

LDGM_session_gpu() [2/2]

LDGM_session_gpu::LDGM_session_gpu

(

const LDGM_session_gpu &

other

)

~LDGM_session_gpu()

LDGM_session_gpu::~LDGM_session_gpu

(

)

Definition at line 60 of file ldgm-session-gpu.cpp.

                                     {
    printf("LDGM TIME GPU: %f ms\n",this->elapsed_sum2/(double)this->no_frames2 );
    cudaError_t error;
    while (!freeBuffers.empty()) {
        char *buf = freeBuffers.front();
        freeBuffers.pop();
        error = cudaFreeHost(buf);
        if(error != cudaSuccess)printf("memoryPool: %s\n", cudaGetErrorString(error));
    }
 
    error = cudaFreeHost(error_vec);
    cuda_check_error("error_vec");
    error = cudaFreeHost(sync_vec);
    cuda_check_error("sync_vec");
 
 
    //    cudaFree(OUTBUF);
    cudaFree(PCM);
 
    cudaFree(ERROR_VEC);
    cudaFree(SYNC_VEC);
}                           /* destructor       */

References cudaError_t, cudaFree, cudaFreeHost, cudaGetErrorString, cudaSuccess, LDGM_session::elapsed_sum2, ERROR_VEC, error_vec, freeBuffers, LDGM_session::no_frames2, PCM, SYNC_VEC, and sync_vec.

Member Function Documentation

alloc_buf()

void * LDGM_session_gpu::alloc_buf ( int size )

virtual

Implements LDGM_session.

Definition at line 83 of file ldgm-session-gpu.cpp.

{
    // printf("cudaHostAlloc %d %d\n",this->indexMemoryPool,index);
    // printf("buf_size %d, bufferSize %d\n",buf_size,this->memoryPoolSize[index] );
    while (!freeBuffers.empty()) {
            char *buf = freeBuffers.front();
            freeBuffers.pop();
 
            if (buf_size <= (int) bufferSizes[buf]) {
                    return buf;
            } else {
                    cudaFreeHost(buf);
                    cuda_check_error("cudaFreeHost");
                    bufferSizes.erase(buf);
            }
    }
 
    char *buf;
    cudaHostAlloc((void **) &buf, buf_size, cudaHostAllocDefault);
    // cudaHostAlloc(&this->memoryPool[index], buf_size, cudaHostAllocMapped);
    cuda_check_error("cudaHostAlloc");
    bufferSizes[buf] = buf_size;
 
    return buf;
}

References bufferSizes, cudaFreeHost, cudaHostAlloc, cudaHostAllocDefault, and freeBuffers.

decode()

void LDGM_session_gpu::decode

(

)

decode_frame()

char * LDGM_session_gpu::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 165 of file ldgm-session-gpu.cpp.

{
    char *received = received_data;
 
    Timer_util interval;
    interval.start();
 
    int p_size = buf_size / (param_m + param_k);
    // printf("%d p_size K: %d, M: %d, buf_size: %d, max_row_weight: %d \n",p_size,param_k,param_m,buf_size,max_row_weight);
 
    //We need to merge intervals in the valid data vector
    std::map <int, int> merged_intervals;
    std::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 ( std::pair<int, int> (start, length) );
        }
    }
 
    
 
    cudaError_t error;
    if (error_vec == NULL)
    {
        cudaHostAlloc((void **) &error_vec, sizeof(int) * (param_k + param_m), cudaHostAllocDefault );
        cuda_check_error("error_vec");
    }
 
    if (sync_vec == NULL)
    {
        cudaHostAlloc((void **) &sync_vec, sizeof(int) * (param_k + param_m), cudaHostAllocDefault );
        cuda_check_error("sync_vec");
    }
 
    // error_vec= (int* ) malloc(sizeof(int)*(param_k+param_m));
    memset(error_vec, 0, sizeof(int) * (param_k + param_m));
    // sync_vec= (int* ) malloc(sizeof(int)*(param_k+param_m));
    memset(sync_vec, 0, sizeof(int) * (param_k + param_m));
    int not_done = 0;
 
    if ( merged_intervals.size() != 0
       )
    {
 
        for (int i = 0; i < param_k + param_m; i++)
        {
            int node_offset = i * p_size;
 
            map_it = merged_intervals.begin();
 
            bool found = false;
            while ( (map_it->first <= node_offset) && map_it != merged_intervals.end() )
            {
                map_it++;
                found = true;
            }
            if ( found ) map_it--;
 
            if ( found && (map_it->first + map_it->second) >=
                    (node_offset + p_size) )
            {
                //OK
                error_vec[i] = 0;
                sync_vec[i] = 0;
            }
            else
            {
                //NOK
                memset(received + (i * p_size), 0x0, p_size);
                error_vec[i] = 1;
                sync_vec[i] = 1;
                not_done++;
            }
 
        }
 
    }
    
 
 
    //-------------------------------------------------------------------------------------------------------
 
 
 
 
 
    /* 
     * struct coding_params params;
     * params.k = param_k;
     * params.m = param_m;
     * params.max_row_weight = max_row_weight;
     * params.packet_size = p_size;
     * params.buf_size = buf_size;
     */
     unsigned int w_f = max_row_weight + 2;
 
 
    // printf("K: %d, M: %d, max_row_weight: %d, buf_size: %d,\n", param_k, param_m, max_row_weight, buf_size );
    // printf("not done: %d\n", not_done);
 
    // int * sync_vec_d;
    // int * error_vec_d;
    // int * pcm_d;
 
    if (PCM == NULL)
    {
        error = cudaMalloc((void **) &PCM, w_f * param_m * sizeof(int));
        if (error != cudaSuccess) printf("3 %s\n", cudaGetErrorString(error));
 
        error = cudaMemcpy(PCM, pcm, w_f * param_m * sizeof(int), cudaMemcpyHostToDevice);
        if (error != cudaSuccess) printf("4 %s\n", cudaGetErrorString(error));
    }
 
    if (SYNC_VEC == NULL)
    {
        error = cudaMalloc((void **) &SYNC_VEC, (param_m + param_k) * sizeof(int));
        if (error != cudaSuccess) printf("7 %s\n", cudaGetErrorString(error));
    }
 
    cudaMemcpy(SYNC_VEC, sync_vec, (param_m + param_k) * sizeof(int), cudaMemcpyHostToDevice);
    cuda_check_error("SYNC_VEC");
 
 
    if (ERROR_VEC == NULL)
    {
        cudaMalloc((void **) &ERROR_VEC, (param_m + param_k) * sizeof(int));
        cuda_check_error("ERROR_VEC");
    }
 
    cudaMemcpy(ERROR_VEC, error_vec, (param_m + param_k) * sizeof(int), cudaMemcpyHostToDevice);
    cuda_check_error("ERROR_VEC");
 
    // // }else{
    // //     error = cudaMemcpy(ERROR_VEC, sync_vec, (param_m + param_k) * sizeof(int), cudaMemcpyHostToDevice);
    // //     if (error != cudaSuccess) printf("8 %s\n", cudaGetErrorString(error));
    // // }
 
    //(char *data, int * PCM,int* SYNC_VEC,int* ERROR_VEC, int not_done, int *frame_size,int * error_vec,int * sync_vec,int M,int K,int w_f,int buf_size,int packet_size)
    // if (not_done != 0)
    // {
    //     gpu_decode_upgrade(received, PCM, SYNC_VEC, ERROR_VEC, not_done, frame_size, error_vec, sync_vec, param_m, param_k, w_f, buf_size, p_size);
    // }
    // else
    // {
    //     int fs = 0;
    //     memcpy(&fs, received, 4);
    //     *frame_size = fs;
    //     printf("frame_size: %d\n",frame_size );
    // }
 
    gpu_decode_upgrade(received, PCM, SYNC_VEC, ERROR_VEC, not_done, frame_size, error_vec, sync_vec, param_m, param_k, w_f, buf_size, p_size);
 
#if 0
     assert(LDGM_session::HEADER_SIZE >= 12)
     int my_frame_size = 0;
     memcpy(&my_frame_size, received + 8, 4);
        int crc_origin = 0;
         memcpy(&crc_origin, received + 4, 4);
 
       // printf("my_frame_size: %d\n",my_frame_size );
         int crc =0;
         crc = crc32buf(received + LDGM_session::HEADER_SIZE, my_frame_size);
 
         if (crc_origin != crc)
         {
             printf("CRC NOK\n");
 
         }
#endif
 
    // if (*frame_size != 0)
    // {
 
    //     int my_frame_size = 0;
    //     memcpy(&my_frame_size, received + 8, 4);
    //     int crc_origin = 0;
    //     memcpy(&crc_origin, received + 4, 4);
 
    //     // printf("my_frame_size: %d\n",my_frame_size );
    //     int crc =0;
    //     // crc32buf(received + 12, my_frame_size);
 
    //     if (crc_origin != crc)
    //     {
    //         printf("CRC NOK1\n");
 
    //     }
    // }
    // else
    // {
    //     printf("CRC NOK\n");
    // }
 
    interval.end();
    //printf("time: %e\n",elapsed/1000.0 );
    this->elapsed_sum2 += interval.elapsed_time_ms();
    this->no_frames2++;
 
    return received + LDGM_session::HEADER_SIZE;
 
}

References crc32buf(), cudaError_t, cudaGetErrorString, cudaHostAlloc, cudaHostAllocDefault, cudaMalloc, cudaMemcpy, cudaMemcpyHostToDevice, cudaSuccess, LDGM_session::elapsed_sum2, Timer_util::elapsed_time_ms(), Timer_util::end(), ERROR_VEC, error_vec, first, gpu_decode_upgrade(), LDGM_session::HEADER_SIZE, LDGM_session::max_row_weight, LDGM_session::no_frames2, LDGM_session::param_k, LDGM_session::param_m, PCM, LDGM_session::pcm, start(), Timer_util::start(), SYNC_VEC, and sync_vec.

Here is the call graph for this function:

encode()

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

virtual

Implements LDGM_session.

Definition at line 116 of file ldgm-session-gpu.cpp.

{
    assert(parity == source_data+param_k*get_packet_size());
 
    unsigned int w_f = max_row_weight + 2;
    unsigned int buf_size = (param_k + param_m) * packet_size;
 
    cudaError_t error;
 
    // error = cudaHostGetDevicePointer( &(out_buf_d), source_data, 0);
    // cuda_check_error("out_buf_d");
 
    if(OUTBUF==NULL){
        // puts("cudaMalloc");
        cudaMalloc((void **) &OUTBUF,buf_size);
        OUTBUF_SIZE=buf_size;
    }
    if((int)buf_size>OUTBUF_SIZE){
        // puts("cudaMalloc");
        cudaFree(OUTBUF);
        cudaMalloc((void **) &OUTBUF,buf_size);
        OUTBUF_SIZE=buf_size;
    }
 
        cudaMemcpy((void *) OUTBUF,source_data,buf_size,cudaMemcpyHostToDevice);
    cuda_check_error("memcpy OUTBUF");
 
 
 
    if (PCM == NULL)
    {   
        // puts("cudaMalloc");      
        error = cudaMalloc((void **) &PCM, w_f * param_m * sizeof(int));
        if(error != cudaSuccess)printf("7CUDA error: %s\n", cudaGetErrorString(error));
 
        error = cudaMemcpy(PCM, pcm, w_f * param_m * sizeof(int), cudaMemcpyHostToDevice);
        if(error != cudaSuccess)printf("8CUDA error: %s\n", cudaGetErrorString(error));
    }
 
 
 
 
 
    gpu_encode_upgrade(source_data,OUTBUF , PCM, param_k, param_m, w_f, packet_size, buf_size);
 
    // puts("end");
 
}

References cudaError_t, cudaFree, cudaGetErrorString, cudaMalloc, cudaMemcpy, cudaMemcpyHostToDevice, cudaSuccess, LDGM_session::get_packet_size(), gpu_encode_upgrade(), LDGM_session::max_row_weight, OUTBUF, OUTBUF_SIZE, LDGM_session::packet_size, LDGM_session::param_k, LDGM_session::param_m, PCM, and LDGM_session::pcm.

Here is the call graph for this function:

encode_naive()

void LDGM_session_gpu::encode_naive ( char * , char *  )

inlinevirtual

Implements LDGM_session.

Definition at line 62 of file ldgm-session-gpu.h.

{}

free_out_buf()

void LDGM_session_gpu::free_out_buf ( char * buf )

virtual

Implements LDGM_session.

Definition at line 109 of file ldgm-session-gpu.cpp.

{
    if ( buf != NULL ) {
         freeBuffers.push(buf);
    }
}

References freeBuffers.

set_data_fname()

void LDGM_session_gpu::set_data_fname ( char fname[32] )

inline

Definition at line 74 of file ldgm-session-gpu.h.

{ strncpy(data_fname, fname, 32); }

References data_fname.

Member Data Documentation

bufferSizes

std::map<char *, size_t> LDGM_session_gpu::bufferSizes

private

Definition at line 84 of file ldgm-session-gpu.h.

Referenced by alloc_buf().

data_fname

char LDGM_session_gpu::data_fname[32]

private

Definition at line 81 of file ldgm-session-gpu.h.

Referenced by set_data_fname().

ERROR_VEC

int* LDGM_session_gpu::ERROR_VEC

private

Definition at line 93 of file ldgm-session-gpu.h.

Referenced by LDGM_session_gpu(), ~LDGM_session_gpu(), and decode_frame().

error_vec

int* LDGM_session_gpu::error_vec

private

Definition at line 89 of file ldgm-session-gpu.h.

Referenced by LDGM_session_gpu(), ~LDGM_session_gpu(), and decode_frame().

freeBuffers

std::queue<char *> LDGM_session_gpu::freeBuffers

private

Definition at line 83 of file ldgm-session-gpu.h.

Referenced by ~LDGM_session_gpu(), alloc_buf(), and free_out_buf().

OUTBUF

int* LDGM_session_gpu::OUTBUF

private

Definition at line 87 of file ldgm-session-gpu.h.

Referenced by LDGM_session_gpu(), and encode().

OUTBUF_SIZE

int LDGM_session_gpu::OUTBUF_SIZE

private

Definition at line 86 of file ldgm-session-gpu.h.

Referenced by LDGM_session_gpu(), and encode().

PCM

int* LDGM_session_gpu::PCM

private

Definition at line 95 of file ldgm-session-gpu.h.

Referenced by LDGM_session_gpu(), ~LDGM_session_gpu(), decode_frame(), and encode().

SYNC_VEC

int* LDGM_session_gpu::SYNC_VEC

private

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

Referenced by LDGM_session_gpu(), ~LDGM_session_gpu(), and decode_frame().

sync_vec

int* LDGM_session_gpu::sync_vec

private

Definition at line 90 of file ldgm-session-gpu.h.

Referenced by LDGM_session_gpu(), ~LDGM_session_gpu(), and decode_frame().

---

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

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