• State
  • Locked Locked
  • Replies 7 replies
  • Subscribers 99 subscribers
  • Views 771 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

TDA2: VCOP register allocation failed error while compiling

Shruti Joshi
Intellectual 400 points
Part Number: TDA2

Hi,

I have written a code in Kernel C for an algorithm. I am trying to compile the code through CCS7.4, but I get the following error while compiling:

Can anyone please help me understand why this error is generated?

Regards,

Shruti

  • 0
    TI__Guru 56820 points
    Shruti,
    This means that your loop needs more registers than available register in VCOP. Without looking at the kernel code its difficult to comment more. If you can share your kernel then we can have look at it and comment more. If not then you should check the generated assembly code and see the registers used by the VCOP.

    Regards,
    Anshu
  • 0 in reply to Anshu Jain
    TI__Guru 56820 points
    Shruti,
    Were you able to make progress on this issue? If yes, please close this thread. If not then let us know about it.

    Regards,
    Anshu
  • 0 in reply to Anshu Jain
    Intellectual 400 points

    Hi Anshu,

    Sorry for the late response. I tried looking into the assembly code, but not found any lead.  I am attaching my kernel C code here for reference. Can you please have a look at it?

    Fullscreen sobel.txt Download 
    /*==========================================================================*/
/*      Copyright (C) 2009-2013 Texas Instruments Incorporated.             */
/*                      All Rights Reserved                                 */
/*==========================================================================*/

/*----------------------------------------------------------------------------*/
/* NAME: eve_sobel_edge_detect                                              */
/*                                                                            */
/*                                                                            */
/* DESCRIPTION:                                                               */
/*                                                                            */
/* The function "eve_sobel_edge_detect" takes input image                     */
/* inptr, and runs the sobel operator on it and writes it out to              */
/* the output array "optr". The input and output arrays are 2D arrays         */
/* of the form [width * height].                                              */
/*                                                                            */
/* The function has the following prototype:                                  */
/*                                                                            */
/* void eve_sobel_edge_detect                                                 */
/* (                                                                          */
/*    __vptr_uint8  inptr,            // input data pointer                   */
/*    __vptr_uint8  optr,             // output data pointer                  */
/*    unsigned int width,           // width of input image                   */
/*    unsigned int height           // height of input image                  */
/* )                                                                          */
/*                                                                            */
/*----------------------------------------------------------------------------*/

#define ELEMSZ           sizeof(*inptr)
#define VECTORSZ        (VCOP_SIMD_WIDTH*ELEMSZ)
#define ELEMSZ_OUT       sizeof(*optr)
#define VECTORSZ_OUT     (VCOP_SIMD_WIDTH * ELEMSZ_OUT)
#define VCOP_2SIMD_WIDTH    (2 * VCOP_SIMD_WIDTH)

void vcop_detectEdge(
__vptr_uint8  inptr,
__vptr_uint8  optr,
__vptr_uint8 intsumx,
unsigned int width,
unsigned int height)
{
  __vector Vin, Vin1;
  __vector Vout, Vout1;
  __vector Vreg1, Vreg11;
  __vector Vreg2, Vreg12;
  __vector Vreg3, Vreg13;
  __vector Vreg4, Vreg14;
  __vector Vreg5, Vreg15;
  __vector Vsumx, Vsumx1;
  __vector Vsumy, Vsumy1;
  
  __vector Vshift = -1;
  __vector Vin01, Vin02;
  __vector Vin03, Vin13;
  __vector Vin04, Vin14;


  for(int Irow = 0; Irow < (height - 2); Irow++)
  {
      for(int Icol = 0; Icol < (width / VCOP_2SIMD_WIDTH); Icol++)
      {
        __agen addr;
        addr = Irow * (width * ELEMSZ) + Icol* (VCOP_SIMD_WIDTH* ELEMSZ);

        (Vin, Vin1) = inptr[addr].deinterleave();
        (Vreg1, Vreg11) = (inptr + (2*width) +(2 * sizeof(*inptr)))[addr].deinterleave();
        Vreg1 = Vreg1 - Vin;
        Vreg11 = Vreg11 - Vin1;

        (Vreg2, Vreg12) = (inptr + (2*width))[addr].deinterleave();
        (Vreg3, Vreg13) = (inptr + (2*sizeof(*inptr)))[addr].deinterleave();
        Vreg3 = Vreg3 - Vreg2;
        Vreg13 = Vreg13 - Vreg12;

        (Vreg4, Vreg14) = (inptr + width)[addr].deinterleave();
        (Vreg5, Vreg15) = (inptr + width + (2 * sizeof(*inptr)))[addr].deinterleave();

       // Vtemp1 = Vreg4 + Vreg4;
        Vreg14 += Vreg14;
        Vsumx = Vreg5 + Vreg5;
        Vsumx -= Vreg4;// - Vreg4
        Vsumx -= Vreg4;

        Vreg15 += Vreg15;

        //Vsumx = Vtemp2 - Vtemp1;
        Vsumx += Vreg1 + Vreg3;

        Vsumx1 = Vreg15 - Vreg14;
        Vsumx1 = Vreg11 + Vreg13;
        //Vsumx1 = Vtemp12 - Vtemp11;


        //Vsumx += Vdata2;

        Vsumx = abs(Vsumx);
        Vsumx1 = abs(Vsumx1);

        (intsumx + width + sizeof(*inptr))[addr].interleave() = (Vsumx, Vsumx1);
        //(optr + width + sizeof(*inptr))[addr] = Vsumx;
      }
  }


  for(int Irow = 0; Irow < (height - 2); Irow++)
  {
      for(int Icol = 0; Icol < (width / VCOP_2SIMD_WIDTH); Icol++)
      {
          __agen addr;
          addr = Irow * (width * ELEMSZ) + Icol* (2 * VCOP_SIMD_WIDTH * ELEMSZ);

          (Vsumx, Vsumx1) = (intsumx + width + sizeof(*inptr))[addr].deinterleave();
          (Vin, Vin1) = inptr[addr].deinterleave();
          (Vreg1, Vreg11) = (inptr + (2*width) +(2 * sizeof(*inptr)))[addr].deinterleave();

          Vreg1 = Vreg1 - Vin;
          Vreg11 = Vreg11 - Vin1;


          (Vreg2, Vreg12) = (inptr + (2*width))[addr].deinterleave();
          (Vreg3, Vreg13) = (inptr + (2*sizeof(*inptr)))[addr].deinterleave();
          Vreg3 = Vreg3 - Vreg2;
          Vreg13 = Vreg13 - Vreg12;

          (Vreg4, Vreg14) = (inptr + (sizeof(*inptr)))[addr].deinterleave();
          (Vreg5, Vreg15) = (inptr + (2*width) + (sizeof(*inptr)))[addr].deinterleave();

          Vreg4 += Vreg4;
          Vreg14 += Vreg14;

          Vreg5 += Vreg5;
          Vreg15 += Vreg15;

          Vreg4 -= Vreg5;
          Vreg14 -= Vreg15;

          Vreg1 -= Vreg3;
          Vreg1-= Vreg4;

          Vreg11 -= Vreg13;
          Vreg11 -= Vreg14;

          Vreg1 = abs(Vreg1);
          Vreg11 = abs(Vreg11);


          Vout = Vsumx + Vreg1;
          Vout1 = Vsumx1 + Vreg11;

          Vout = Vout << Vshift;
          Vout1 = Vout1 << Vshift;

         // Vsumy = Vout << Vshift;
          //Vsumy1 = Vout1 << Vshift;


          //(optr + width + sizeof(*inptr))[addr].interleave() = (Vsumy, Vsumy1);
          (optr + width + sizeof(*inptr))[addr].interleave() = (Vout, Vout1);
      }
  }

  for(int col= 0;col < height-1; col++)
               {
                   __agen AddrIn  = col* width *ELEMSZ;
                   __agen AddrOut = col*width *ELEMSZ_OUT;

                   Vin01= (optr + (width+1) * sizeof(*optr))[AddrIn].onept();
                   Vin02= (optr+(2*width-2)*sizeof(*optr))[AddrIn].onept();

                   (optr + width  * sizeof(*optr))[AddrOut].onept() = Vin01;
                   (optr+(2*width)-sizeof(*optr))[AddrOut].onept() = Vin02;

               }

               for(int col = 0; col < width/VCOP_2SIMD_WIDTH; col++)

               {

                 __agen Addr1= col*(2 * VECTORSZ_OUT);
                 (Vin03, Vin13) = (optr+width)[Addr1].deinterleave();
                 (Vin04, Vin14) = (optr+width *(height-2))[Addr1].deinterleave();

               (optr)[Addr1].interleave() = (Vin03, Vin13);
               (optr+width*(height-1))[Addr1].interleave() = (Vin04, Vin14);
               }

#if 0
  for(int Irow = 0; Irow < (height); Irow++)
  {
      for(int Icol = 0; Icol < (width / VCOP_SIMD_WIDTH); Icol++)
      {
        __agen addr;
        addr = Irow * (width * ELEMSZ) + Icol* (VCOP_SIMD_WIDTH* ELEMSZ);

        Vin = inptr[addr];
        Vreg1 = (inptr +(2 * sizeof(*inptr)))[addr];
        Vdata1 = Vreg1 - Vin;

        Vreg2 = (inptr + (width*2))[addr];
        Vreg3 = (inptr + (width*2) + (2 * sizeof(*inptr)))[addr];
        Vdata2 = Vreg3 - Vreg2;

        Vreg4 = (inptr + width)[addr];
        Vreg5 = (inptr + width + (2 * sizeof(*inptr)))[addr];

        Vtemp1 = Vreg4 + Vreg4;
        Vtemp2 = Vreg5 + Vreg5;

        Vsumx = Vtemp2 - Vtemp1;
        Vsumx += Vdata1 + Vdata2;
        //Vsumx += Vdata2;

        Vsumx = abs(Vsumx);

        intsumx[addr] = Vsumx;
      }
  }
  for(int Irow = 0; Irow < (height); Irow++)
  {
      for(int Icol = 0; Icol < (width / VCOP_SIMD_WIDTH); Icol++)
      {
        __agen addr;
        addr = Irow * (width * ELEMSZ) + Icol* (VCOP_SIMD_WIDTH* ELEMSZ);

        Vsumx = intsumx[addr];
        Vin = inptr[addr];
        Vreg1 = (inptr + (width*2))[addr];
        Vdata1 = Vreg1 - Vin;

        Vreg2 = (inptr + (2*sizeof(*inptr)))[addr];
        Vreg3 = (inptr + (width*2) + (2*sizeof(*inptr)))[addr];
        Vdata2 = Vreg3 - Vreg2;

        Vreg4 = (inptr + (sizeof(*inptr)))[addr];
        Vreg5 = (inptr + (width*2) + (sizeof(*inptr)))[addr];

        Vtemp1 = Vreg4 + Vreg4;
        Vtemp2 = Vreg5 + Vreg5;

        Vsumy = Vtemp2 - vtemp1;
        Vsumy+=Vdata1;
        Vsumy+=Vdata2;

        Vsumy = abs(Vsumy);

        Vout = Vsumx + Vsumy;
        Vout = Vout << Vshift;

        outptr[addr] = Vout;
      }
  }
#endif
}

    The code is for the Sobel edge detection algorithm. The commented part is the original algorithm, which is later converted to interleaved format.

    Regards,

    Shruti

  • 0 in reply to Shruti Joshi
    TI__Guru 56820 points
    Shruti,
    I tried compiling the code you shared and I don't see any build error. Following are my compiler options. Can you make sure the compiler options are the same :

    C:\ti\ccsv7.3\tools\compiler\arp32_1.0.9\bin\cl-arp32 -g --opt_for_speed=5 -kh --silicon_version=v210 -lu --display_error_number --diag_suppress=26066 --diag_suppress=10063 -IC:\ti\ccsv7.3\tools\compiler\arp32_1.0.9\include -IC:\ti\ccsv7.3\tools\compiler\arp32_1.0.9\include\vcop -I"..\inc" -I"..\..\..\inc" --temp_directory="..\..\..\inc" --obj_directory="..\src_kernelC" ..\src_kernelC\vcop_sobel_xy_kernel.k

    Regards,
    Anshu
  • 0 in reply to Anshu Jain
    Intellectual 400 points
    Hi Anshu,

    There are few differences in my compiler options. Below is my compiler log:

    "C:\\ti\\ccsv7\\utils\\bin\\gmake" -k -j 4 all -O

    'Building file: "../main.c"'
    'Invoking: EVE Compiler'
    "C:/ti/ccsv7/tools/compiler/arp32_1.0.9/bin/cl-arp32" -v210 -g --include_path="C:/ti/ccsv7/tools/compiler/arp32_1.0.9/include/vcop" --include_path="C:/Users/shruti.joshi/workspace_v7/Sobel_interleave" --include_path="C:/ti/ccsv7/tools/compiler/arp32_1.0.9/include" --diag_warning=225 --display_error_number --diag_wrap=off --preproc_with_compile --preproc_dependency="main.d_raw" "../main.c"
    'Finished building: "../main.c"'

    'Building file: "../sobel.k"'
    'Invoking: EVE Compiler'
    "C:/ti/ccsv7/tools/compiler/arp32_1.0.9/bin/cl-arp32" -v210 -g --include_path="C:/ti/ccsv7/tools/compiler/arp32_1.0.9/include/vcop" --include_path="C:/Users/shruti.joshi/workspace_v7/Sobel_interleave" --include_path="C:/ti/ccsv7/tools/compiler/arp32_1.0.9/include" --diag_warning=225 --display_error_number --diag_wrap=off --preproc_with_compile --preproc_dependency="sobel.d_raw" "../sobel.k"

    >> Compilation failure
    subdir_rules.mk:16: recipe for target 'sobel.obj' failed
    error:
    VCOP register allocation failed.
    Please restructure and/or hand-allocate the kernel function.

    gmake: *** [sobel.obj] Error 1
    gmake: Target 'all' not remade because of errors.

    **** Build Finished ****

    I will try to match the configurations with yours and let you know the results.

    Regards,
    Shruti
  • 0 in reply to Shruti Joshi
    TI__Guru 56820 points
    Hi Shruti,
    Were you able to make these compiler option changes? If yes are you still seeing "VCOP register allocation failed" error?

    Regards,
    Anshu
  • 0 in reply to Anshu Jain
    TI__Guru 56820 points
    Shruti,
    I am closing this thread as we haven't heard back from you. If required please re-open this thread again.

    Regards,
    Anshu