ldgm-session-cpu.cpp File Reference

#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "ldgm-session-cpu.h"
#include "timer-util.h"
#include <errno.h>

Include dependency graph for ldgm-session-cpu.cpp:

Go to the source code of this file.

Macros
#define	aligned_free   free

Functions
static void *	aligned_malloc (size_t size, size_t alignment)
void	iterate (Tanner_graph *g)
static char *	xor_using_sse (char *source, char *dest, int packet_size)

Macro Definition Documentation

aligned_free

#define aligned_free   free

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

Referenced by vidcap_state_aja::CaptureFrames(), aligned_data_allocator::deallocate(), LDGM_session_cpu::encode(), LDGM_session_cpu::encode_naive(), free_entry(), LDGM_session_cpu::free_out_buf(), vf_aligned_data_deleter(), and video_reader_callback().

Function Documentation

aligned_malloc()

static void * aligned_malloc ( size_t size, size_t alignment )

inlinestatic

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

{
        void *ptr = NULL;
        int ret;
        ret = posix_memalign(&ptr, alignment, size);
        if(ret) {
                errno = ret;
        }
 
        if(ret == 0) {
                return ptr;
        } else {
                return NULL;
        }
}

Referenced by LDGM_session_cpu::alloc_buf(), aligned_data_allocator::allocate(), vidcap_state_aja::CaptureFrames(), LDGM_session_cpu::encode(), LDGM_session_cpu::encode_naive(), vf_alloc_desc_data(), and video_reader_callback().

iterate()

void iterate

(

Tanner_graph *

g

)

xor_using_sse()

static char * xor_using_sse ( char * source, char * dest, int packet_size )

static

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

{
    // int a = 0;
    // int II = packet_size % 16;
    // a=II*16;
    // // uint64_t* p1 = (uint64_t*) (source);
    // // uint64_t* p2 = (uint64_t*) (dest);
 
    // __int128* p1 = (__int128*) (source);
    // __int128* p2 = (__int128*) (dest);
 
    // for(int i=0; i<II; i++){
    //     *p2 ^= *p1;
    //     p2++;
    //     p1++;
    // }
    // while(a<packet_size){
    //     *(dest + a) ^= *(source+a);
    //     a++;
    // }
    //First, do as many 128-bit XORs as possible
    int iter_bytes_16 = 0;
    int iter_bytes_4 = 0;
    int iter_bytes_1 = 0;
#if defined __SSE2__ || _M_IX86_FP == 2
    iter_bytes_16 = (packet_size/16)*16;
 
    if ( iter_bytes_16 > 0)
    {
 
        //    printf ( "iter_bytes: %d\n", iter_bytes );
        __m128i* wrd_ptr = (__m128i *)(void *) source;
        __m128i* wrd_end = (__m128i *)(void *) (source + iter_bytes_16);
        __m128i* dst_ptr = (__m128i *)(void *) dest;
 
        //    printf ( "wrd_ptr address: %p\n", wrd_ptr );
        do
        {
            __m128i xmm1 = _mm_loadu_si128(wrd_ptr);
            __m128i xmm2 = _mm_loadu_si128(dst_ptr);
 
            xmm1 = _mm_xor_si128(xmm1, xmm2);     //  XOR  4 32-bit words
            _mm_storeu_si128(dst_ptr, xmm1);
            ++wrd_ptr;
            ++dst_ptr;
 
        } while (wrd_ptr < wrd_end);
    }
#endif
    //Check, whether further XORing is necessary
    if ( iter_bytes_16 < packet_size )
    {
        char *mark_source = source + iter_bytes_16;
        char *mark_dest = dest + iter_bytes_16;
 
        iter_bytes_4 = ((packet_size - iter_bytes_16)/4)*4;
 
        for ( int i = 0; i < (packet_size - iter_bytes_16)/4; i++)
        {
            int *s = ((int*)(void *) mark_source) + i;
            int *d = ((int*)(void *) mark_dest) + i;
            *d ^= *s;
        }
 
        mark_source += iter_bytes_4;
        mark_dest += iter_bytes_4;
 
        iter_bytes_1 = packet_size - iter_bytes_16 - iter_bytes_4;
 
        for ( int i = 0; i < iter_bytes_1; i++)
        {
            *(mark_dest + i) ^= *(mark_source+i);
        }
    }
 
//   printf ( "XORed: %d bytes using SSE, %d bytes as ints and %d bytes byte-per-byte.\n",iter_bytes_16, iter_bytes_4, iter_bytes_1);
 
    return dest;
}

Referenced by LDGM_session_cpu::encode(), and LDGM_session_cpu::iterate().