Performance Problem: NAL Unit Wrapping

Question

From what I saw in the past, StackOverflow seems like programming problems, such as fast char for string execution problems that got dozens of answers, This is an optimization task: take a very simple function and see if you can come up with a more reasonable one way to do it.

I had a function that I would like to optimize again for some time, but I always find that my optimizations have some hole leading to an incorrect exit - a rare special case in which they fail. But, given this feature, I always thought that one should be able to do better than that.

The function accepts the input data stream (effectively random bits, in terms of entropy) and transfers it to the NAL block. This includes the placement of escape codes: any sequence of bytes 00 00 00, 00 00 01, 00 00 02 or 00 00 03 is replaced by 00 00 03 XX, where XX is the last byte of the original sequence. As you might guess, they only get about 1 for every 4 million bytes of input, given the chances of such a sequence - so it's a challenge when one is looking for a huge amount of data and does almost nothing for it , except in very rare cases. However, since "doing something" involves inserting bytes, this makes things a little more complicated. The current unoptimized code is as follows: C:

src and dst are pointers to byte arrays, and end is pointers to the end of the input.

int i_count = 0;
while( src < end )
{
    if( i_count == 2 && *src <= 0x03 )
    {
        *dst++ = 0x03;
        i_count = 0;
    }
    if( *src == 0 )
        i_count++;
    else
        i_count = 0;
    *dst++ = *src++;
}

The total input data sizes for this function range from approximately 1,000 to 1,000,000 bytes of data.

My initial ideas include a function that (somehow) quickly searches for input for situations where an exit code is required to avoid more complex logic in the vast majority of inputs where you do not need to place escape codes.

---

Answer 1

Hmm ... how about something like that?

#define likely(x) __builtin_expect((x),1)
#define unlikely(x) __builtin_expect((x),0)

while( likely(src < end) )
{
    //Copy non-zero run
    int runlen = strlen( src );
    if( unlikely(src+runlen >= end) )
    {
        memcpy( dest, src, end-src );
        dest += end-src;
        src = end;
        break;
    }

    memcpy( dest, src, runlen );
    src += runlen;
    dest += runlen;

    //Deal with 0 byte
    if( unlikely(src[1]==0 && src[2]<=3 && src<=end-3) )
    {
        *dest++ = 0;
        *dest++ = 0;
        *dest++ = 3;
        *dest++ = *src++;
    }
    else
    {
        *dest++ = 0;
        src++;
    }
}

There some duplication of effort between strcpy and memcpy would be nice to get rid of this.

Answer 2

Applying obvious optimizations to your code:

#define unlikely(x) __builtin_expect((x),0)

while( src < end )
{
    const char s = *src++;
    if( unlikely(i_count==2 && s<=0x03) )
    {
        *dst++ = 0x03;
        i_count = 0;
    }
    if( unlikely(s==0) )
        i_count++;
    else
        i_count = 0;
    *dst++ = s;
}

Answer 3

, "" : 10% :

#define unlikely(x) __builtin_expect((x),0)
while( src < end )
{
    if( unlikely(i_count == 2) && unlikely(*src <= 0x03) )
    {
        *dst++ = 0x03;
        i_count = 0;
    }
    if( unlikely(*src == 0) )
        i_count++;
    else
        i_count = 0;
    *dst++ = *src++;
}

, 50% , (!!!). , () ... gcc .

#define unlikely(x) __builtin_expect((x),0)
#define likely(x) __builtin_expect((x),1)
while( likely(src < end) )
{
    if( unlikely(i_count == 2) && unlikely(*src <= 0x03) )
    {
        *dst++ = 0x03;
        i_count = 0;
    }
    if( unlikely(*src == 0) )
        i_count++;
    else
        i_count = 0;
    *dst++ = *src++;
}

, ; , , .

Answer 4

while (src < end-2)
{
    if ((src[0] == 0) && (src[1] == 0) && (src[2] <= 3))
    {
        dst[0] = 0;
        dst[1] = 0;
        dst[2] = 3;
        dst[3] = src[2];
        src += 3;
        dst += 4;
    }
    else
        *dst++ = *src++;
}
while (src < end)
    *dst++ = *src++;

Answer 5

:

while (src < end-2)
{
    if (src[0] == 0)
    {
        if (src[1] == 0)
        {
            if (src[2] <= 3)
            {
                dst[0] = 0;
                dst[1] = 0;
                dst[2] = 3;
                dst[3] = src[2];
                src += 3;
                dst += 4;
            }
            else
            {
                dst[0] = 0;
                dst[1] = 0;
                dst[2] = src[2];
                src += 3;
                dst += 3;
            }
        }
        else
        {
            dst[0] = 0;
            dst[1] = src[1];
            src += 2;
            dst += 2;
        }
    }
    else
        *dst++ = *src++;
}
while (src < end)
    *dst++ = *src++;

Answer 6

, , , /. , Mike F strlen/memcpy.

Answer 7

, , , , .

, ( , C/++ ):

• ,
  [ Boyer-Moore , ( )]
• 
  [ , GCC ++ memcpy() , ]