CCS/TDA2EVM5777: Kernel porting on DSP

Hi Vikas,

Can you please elaborate? It will help me identify the issue faster?

Regards,
Shyam

Hi Vikas,

Can you please elaborate? It will help me identify the issue faster?

Regards,
Shyam

I also attaching output which i receive from this code ................

void sobel_dsp_kernel_optimised(uint8_t *inPtr, uint8_t *outPtr, uint32_t width, uint32_t height )
{

       uint8_t *inptr_a1[WIDTH],*inptr_a2[WIDTH],*inptr_a3[WIDTH]; // input buffer to process data
       uint8_t buffer[WIDTH]; // output buffer to process data
       uint8_t *temp1, *inptr1, *inptr2, *inptr3, *outpointer , *inpointer;

       inptr1 = (uint8_t *)inptr_a1 ;
       inptr2 = (uint8_t *)inptr_a2 ;
       inptr3 = (uint8_t *)inptr_a3;

       inpointer = inPtr;
       outpointer = outPtr;
       // copy first row
       memcpy(inptr1 , inpointer , WIDTH);
       inpointer += WIDTH;

       // copy second row
       memcpy(inptr2 , inpointer , WIDTH);
       inpointer += WIDTH;

       // copy third row
       memcpy(inptr3 , inpointer , WIDTH);
       inpointer += WIDTH;

       // copy first row of input directly to output buffer as we are not going to get processed first row
      memcpy(outpointer , inptr1 , WIDTH);
      outpointer += WIDTH;

        int32_t x,y;
        int64_t mask1_8 = 0x0101010101010101;
        int64_t mask2_8 = 0x0202020202020202;
        uint32_t mask1_4 = _loll(mask1_8);
        uint32_t mask2_4 = _loll(mask2_8);
        int64_t r0, r1, r2, r01_lo, r01_hi, r012_lo, r012_hi, r012_lo_d2, r012_hi_d2, c02_lo, c02_hi;
        __x128_t r0_2, r1_2, r2_2;


        for ( y = 1; y < (height-1); y++)
         {
            uint32_t x0_3210 = _mem4_const(inptr1);
            uint32_t x1_3210 = _mem4_const(inptr2);
            uint32_t x2_3210 = _mem4_const(inptr3);

            /* Convert from 8bpp to 16bpp so we can do SIMD addition of rows */
            int64_t x0_2 = _mpyu4ll(x0_3210, mask1_4);
            int64_t x1_2 = _mpyu4ll(x1_3210, mask2_4);
            int64_t x2_2 = _mpyu4ll(x2_3210, mask1_4);

                   /* Add rows 0+1+2, column-wise */
            int32_t x01    = _add2((int32_t)_loll(x0_2), (int32_t)_loll(x1_2));
            uint32_t xaxb  = (uint32_t)_add2(x01, (int32_t)_loll(x2_2));


            for(x=0; x < (width/8); x++)
            {
                /* Read 8 bytes from each of the 3 lines. */
                 r0 = _mem8_const(&inptr1[(x*8) + 2]);
                 r1 = _mem8_const(&inptr2[(x*8) + 2]);
                 r2 = _mem8_const(&inptr3[(x*8) + 2]);

                  /* Convert from 8bpp to 16bpp so we can do SIMD addition of rows */
                 r0_2 = _dmpyu4(r0, mask1_8);
                 r1_2 = _dmpyu4(r1, mask2_8);
                 r2_2 = _dmpyu4(r2, mask1_8);

                     /* Add rows 0+1, column-wise */
                 r01_lo = _dadd2(_lo128(r0_2), _lo128(r1_2));
                 r01_hi = _dadd2(_hi128(r0_2), _hi128(r1_2));

                           /* Add previous sum to row 2, column-wise */
                 r012_lo = _dadd2(r01_lo, _lo128(r2_2));
                 r012_hi = _dadd2(r01_hi, _hi128(r2_2));

                           /* Left shift this sum by 2 pixels, using history */
                 r012_lo_d2 = _itoll(_loll(r012_lo), xaxb);
                 r012_hi_d2 = _itoll(_loll(r012_hi), _hill(r012_lo));

                  c02_lo = _dsub2(r012_lo, r012_lo_d2);
                  c02_hi = _dsub2(r012_hi, r012_hi_d2);

                           /* save overlap data for next iteration */
                  xaxb = (uint32_t)_mvd((int32_t)_hill(r012_hi));

                           /* store 8 sobel filter values */
                  _amem8(&buffer[x*8])     = c02_lo;
                  _amem8(&buffer[(x*8)+4]) = c02_hi;

            }

            memcpy(outpointer, buffer ,WIDTH);
            outpointer += WIDTH;

            // reshuffle the pointer and read one more row
            temp1 = inptr2;
            inptr2 = inptr3;
            inptr1 = temp1;

             // copy third row
             memcpy(inptr3 , inpointer , WIDTH);
             inpointer += WIDTH;
         }
  }

Hi Vikas,

I haven't tried this code yet, but at first glance, I see a potential problem here,

    _amem8(&buffer[x*8])     = c02_lo;

Thanks Shyam for taking time to understand the issue and giving appropriate suggestion.

I have converted the c code in less intrinsics by using _davg2 and _dmin2

//Compute absolute of 2 16-bit values at a time
abs_01 = _abs2(_loll(c02_lo));
abs_23 = _abs2(_hill(c02_lo));
abs_45 = _abs2(_loll(c02_hi));
abs_67 = _abs2(_hill(c02_hi));

//Pack them into groups of 4
c02_lo = _itoll(abs_23 , abs_01 );
c02_hi = _itoll(abs_67 , abs_45 );

//take the average of x direction and y direction edge
c012_lo = _davg2 ( c02_lo , c012_lo);   where  c012_lo is y direction edge
c012_hi = _davg2 ( c02_hi , c012_hi);  where  c012 _hi is y direction edge

// clamp the value with 0xff
c012_lo = _dmin2(c012_lo,MIN_VALUE);
c012_hi = _dmin2(c012_hi,MIN_VALUE);

/* store 8 sobel y filter values */
_mem8(&pixel[0])        =    c012_lo;
_mem8(&pixel[0 + 4])   =   c012_hi;

for (i=0;i<8;i++)
{
buffer[(x*8)+ i] = pixel[i];
}

Now only one thing is remaining , storing data in uint8_t array from int64_t variable.

Thanks

Vikas