← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vlc/maverick

« back to all changes in this revision

Viewing changes to modules/misc/memcpy/fastmemcpy.h

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-09-17 21:56:14 UTC
  • mfrom: (1.1.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20080917215614-tj0vx8xzd57e52t8
Tags: 0.9.2-1ubuntu1
https://launchpad.net/bugs/270404
https://launchpad.net/bugs/210354
https://launchpad.net/bugs/199870
https://launchpad.net/bugs/261567
* New Upstream Release, exception granted by
    - dktrkranz, norsetto, Hobbsee (via irc). LP: #270404

Changes done in ubuntu:

* add libxul-dev to build-depends
* make sure that vlc is build against libxul in configure. This doesn't
  change anything in the package, but makes it more robust if building
  in an 'unclean' chroot or when modifying the package.
* debian/control: make Vcs-* fields point to the motumedia branch
* add libx264-dev and libass-dev to build-depends
  LP: #210354, #199870
* actually enable libass support by passing --enable-libass to configure
* enable libdca: add libdca-dev to build depends and --enable-libdca
* install the x264 plugin.

Changes already in the pkg-multimedia branch in debian:

* don't install usr/share/vlc/mozilla in debian/mozilla-plugin-vlc.install  
* new upstream .desktop file now registers flash video mimetype LP: #261567
* add Xb-Npp-Applications to mozilla-plugin-vlc
* remove duplicate entries in debian/vlc-nox.install

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/misc/memcpy/fastmemcpy.h
1
1
/*****************************************************************************
2
2
 * fastmemcpy.h : fast memcpy routines
3
3
 *****************************************************************************
4
 
 * $Id: efca0490deacaff448ce53e2f9339785736ad50f $
 
4
 * $Id$
5
5
 *
6
6
 * Authors: various Linux kernel hackers
7
7
 *          various MPlayer hackers
11
11
 * it under the terms of the GNU General Public License as published by
12
12
 * the Free Software Foundation; either version 2 of the License, or
13
13
 * (at your option) any later version.
14
 
 * 
 
14
 *
15
15
 * This program is distributed in the hope that it will be useful,
16
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
116
116
{\
117
117
register unsigned long int dummy;\
118
118
__asm__ __volatile__(\
119
 
        "rep; movsb"\
120
 
        :"=&D"(to), "=&S"(from), "=&c"(dummy)\
 
119
    "rep; movsb"\
 
120
    :"=&D"(to), "=&S"(from), "=&c"(dummy)\
121
121
/* It's most portable way to notify compiler */\
122
122
/* that edi, esi and ecx are clobbered in asm block. */\
123
123
/* Thanks to A'rpi for hint!!! */\
124
124
        :"0" (to), "1" (from),"2" (n)\
125
 
        : "memory");\
 
125
    : "memory");\
126
126
}
127
127
 
128
128
#ifdef HAVE_SSE
155
155
 
156
156
void * fast_memcpy(void * to, const void * from, size_t len)
157
157
{
158
 
        void *retval;
159
 
        size_t i;
160
 
        retval = to;
 
158
    void *retval;
 
159
    size_t i;
 
160
    retval = to;
161
161
#ifdef STATISTICS
162
 
        {
163
 
                static int freq[33];
164
 
                static int t=0;
165
 
                int i;
166
 
                for(i=0; len>(1<<i); i++);
167
 
                freq[i]++;
168
 
                t++;
169
 
                if(1024*1024*1024 % t == 0)
170
 
                        for(i=0; i<32; i++)
171
 
                                printf("freq < %8d %4d\n", 1<<i, freq[i]);
172
 
        }
 
162
    {
 
163
        static int freq[33];
 
164
        static int t=0;
 
165
        int i;
 
166
        for(i=0; len>(1<<i); i++);
 
167
        freq[i]++;
 
168
        t++;
 
169
        if(1024*1024*1024 % t == 0)
 
170
            for(i=0; i<32; i++)
 
171
                printf("freq < %8d %4d\n", 1<<i, freq[i]);
 
172
    }
173
173
#endif
174
174
#ifndef HAVE_MMX1
175
175
        /* PREFETCH has effect even for MOVSB instruction ;) */
176
 
        __asm__ __volatile__ (
177
 
                PREFETCH" (%0)\n"
178
 
                PREFETCH" 64(%0)\n"
179
 
                PREFETCH" 128(%0)\n"
180
 
                PREFETCH" 192(%0)\n"
181
 
                PREFETCH" 256(%0)\n"
182
 
                : : "r" (from) );
 
176
    __asm__ __volatile__ (
 
177
            PREFETCH" (%0)\n"
 
178
            PREFETCH" 64(%0)\n"
 
179
            PREFETCH" 128(%0)\n"
 
180
            PREFETCH" 192(%0)\n"
 
181
            PREFETCH" 256(%0)\n"
 
182
        : : "r" (from) );
183
183
#endif
184
184
        if(len >= MIN_LEN)
185
 
        {
186
 
          register unsigned long int delta;
 
185
    {
 
186
      register unsigned long int delta;
187
187
          /* Align destinition to MMREG_SIZE -boundary */
188
188
          delta = ((unsigned long int)to)&(MMREG_SIZE-1);
189
189
          if(delta)
190
 
          {
191
 
            delta=MMREG_SIZE-delta;
192
 
            len -= delta;
193
 
            small_memcpy(to, from, delta);
194
 
          }
195
 
          i = len >> 6; /* len/64 */
196
 
          len&=63;
 
190
      {
 
191
        delta=MMREG_SIZE-delta;
 
192
        len -= delta;
 
193
        small_memcpy(to, from, delta);
 
194
      }
 
195
      i = len >> 6; /* len/64 */
 
196
      len&=63;
197
197
        /*
198
198
           This algorithm is top effective when the code consequently
199
199
           reads and writes blocks which have size of cache line.
204
204
           processor's decoders, but it's not always possible.
205
205
        */
206
206
#ifdef HAVE_SSE /* Only P3 (may be Cyrix3) */
207
 
        if(((unsigned long)from) & 15)
208
 
        /* if SRC is misaligned */
209
 
        for(; i>0; i--)
210
 
        {
211
 
                __asm__ __volatile__ (
212
 
                PREFETCH" 320(%0)\n"
213
 
                "movups (%0), %%xmm0\n"
214
 
                "movups 16(%0), %%xmm1\n"
215
 
                "movups 32(%0), %%xmm2\n"
216
 
                "movups 48(%0), %%xmm3\n"
217
 
                "movntps %%xmm0, (%1)\n"
218
 
                "movntps %%xmm1, 16(%1)\n"
219
 
                "movntps %%xmm2, 32(%1)\n"
220
 
                "movntps %%xmm3, 48(%1)\n"
221
 
                :: "r" (from), "r" (to) : "memory");
222
 
                ((const unsigned char *)from)+=64;
223
 
                ((unsigned char *)to)+=64;
224
 
        }
225
 
        else
226
 
        /*
227
 
           Only if SRC is aligned on 16-byte boundary.
228
 
           It allows to use movaps instead of movups, which required data
229
 
           to be aligned or a general-protection exception (#GP) is generated.
230
 
        */
231
 
        for(; i>0; i--)
232
 
        {
233
 
                __asm__ __volatile__ (
234
 
                PREFETCH" 320(%0)\n"
235
 
                "movaps (%0), %%xmm0\n"
236
 
                "movaps 16(%0), %%xmm1\n"
237
 
                "movaps 32(%0), %%xmm2\n"
238
 
                "movaps 48(%0), %%xmm3\n"
239
 
                "movntps %%xmm0, (%1)\n"
240
 
                "movntps %%xmm1, 16(%1)\n"
241
 
                "movntps %%xmm2, 32(%1)\n"
242
 
                "movntps %%xmm3, 48(%1)\n"
243
 
                :: "r" (from), "r" (to) : "memory");
244
 
                ((const unsigned char *)from)+=64;
245
 
                ((unsigned char *)to)+=64;
246
 
        }
 
207
    if(((unsigned long)from) & 15)
 
208
    /* if SRC is misaligned */
 
209
    for(; i>0; i--)
 
210
    {
 
211
        __asm__ __volatile__ (
 
212
        PREFETCH" 320(%0)\n"
 
213
        "movups (%0), %%xmm0\n"
 
214
        "movups 16(%0), %%xmm1\n"
 
215
        "movups 32(%0), %%xmm2\n"
 
216
        "movups 48(%0), %%xmm3\n"
 
217
        "movntps %%xmm0, (%1)\n"
 
218
        "movntps %%xmm1, 16(%1)\n"
 
219
        "movntps %%xmm2, 32(%1)\n"
 
220
        "movntps %%xmm3, 48(%1)\n"
 
221
        :: "r" (from), "r" (to) : "memory");
 
222
        ((const unsigned char *)from)+=64;
 
223
        ((unsigned char *)to)+=64;
 
224
    }
 
225
    else
 
226
    /*
 
227
       Only if SRC is aligned on 16-byte boundary.
 
228
       It allows to use movaps instead of movups, which required data
 
229
       to be aligned or a general-protection exception (#GP) is generated.
 
230
    */
 
231
    for(; i>0; i--)
 
232
    {
 
233
        __asm__ __volatile__ (
 
234
        PREFETCH" 320(%0)\n"
 
235
        "movaps (%0), %%xmm0\n"
 
236
        "movaps 16(%0), %%xmm1\n"
 
237
        "movaps 32(%0), %%xmm2\n"
 
238
        "movaps 48(%0), %%xmm3\n"
 
239
        "movntps %%xmm0, (%1)\n"
 
240
        "movntps %%xmm1, 16(%1)\n"
 
241
        "movntps %%xmm2, 32(%1)\n"
 
242
        "movntps %%xmm3, 48(%1)\n"
 
243
        :: "r" (from), "r" (to) : "memory");
 
244
        ((const unsigned char *)from)+=64;
 
245
        ((unsigned char *)to)+=64;
 
246
    }
247
247
#else
248
 
        /* Align destination at BLOCK_SIZE boundary */
249
 
        for(; ((ptrdiff_t)to & (BLOCK_SIZE-1)) && i>0; i--)
250
 
        {
251
 
                __asm__ __volatile__ (
 
248
    /* Align destination at BLOCK_SIZE boundary */
 
249
    for(; ((uintptr_t)to & (BLOCK_SIZE-1)) && i>0; i--)
 
250
    {
 
251
        __asm__ __volatile__ (
252
252
#ifndef HAVE_MMX1
253
 
                PREFETCH" 320(%0)\n"
 
253
            PREFETCH" 320(%0)\n"
254
254
#endif
255
 
                "movq (%0), %%mm0\n"
256
 
                "movq 8(%0), %%mm1\n"
257
 
                "movq 16(%0), %%mm2\n"
258
 
                "movq 24(%0), %%mm3\n"
259
 
                "movq 32(%0), %%mm4\n"
260
 
                "movq 40(%0), %%mm5\n"
261
 
                "movq 48(%0), %%mm6\n"
262
 
                "movq 56(%0), %%mm7\n"
263
 
                MOVNTQ" %%mm0, (%1)\n"
264
 
                MOVNTQ" %%mm1, 8(%1)\n"
265
 
                MOVNTQ" %%mm2, 16(%1)\n"
266
 
                MOVNTQ" %%mm3, 24(%1)\n"
267
 
                MOVNTQ" %%mm4, 32(%1)\n"
268
 
                MOVNTQ" %%mm5, 40(%1)\n"
269
 
                MOVNTQ" %%mm6, 48(%1)\n"
270
 
                MOVNTQ" %%mm7, 56(%1)\n"
271
 
                :: "r" (from), "r" (to) : "memory");
 
255
        "movq (%0), %%mm0\n"
 
256
        "movq 8(%0), %%mm1\n"
 
257
        "movq 16(%0), %%mm2\n"
 
258
        "movq 24(%0), %%mm3\n"
 
259
        "movq 32(%0), %%mm4\n"
 
260
        "movq 40(%0), %%mm5\n"
 
261
        "movq 48(%0), %%mm6\n"
 
262
        "movq 56(%0), %%mm7\n"
 
263
        MOVNTQ" %%mm0, (%1)\n"
 
264
        MOVNTQ" %%mm1, 8(%1)\n"
 
265
        MOVNTQ" %%mm2, 16(%1)\n"
 
266
        MOVNTQ" %%mm3, 24(%1)\n"
 
267
        MOVNTQ" %%mm4, 32(%1)\n"
 
268
        MOVNTQ" %%mm5, 40(%1)\n"
 
269
        MOVNTQ" %%mm6, 48(%1)\n"
 
270
        MOVNTQ" %%mm7, 56(%1)\n"
 
271
        :: "r" (from), "r" (to) : "memory");
272
272
                from = (const void *) (((const unsigned char *)from)+64);
273
 
                to = (void *) (((unsigned char *)to)+64);
274
 
        }
 
273
        to = (void *) (((unsigned char *)to)+64);
 
274
    }
275
275
 
276
 
/*      printf(" %p %p\n", (ptrdiff_t)from&1023, (ptrdiff_t)to&1023); */
277
 
        /* Pure Assembly cuz gcc is a bit unpredictable ;) */
 
276
/*    printf(" %p %p\n", (uintptr_t)from&1023, (uintptr_t)to&1023); */
 
277
    /* Pure Assembly cuz gcc is a bit unpredictable ;) */
278
278
# if 0
279
 
        if(i>=BLOCK_SIZE/64)
280
 
                asm volatile(
281
 
                        "xorl %%eax, %%eax      \n\t"
282
 
                        ".balign 16             \n\t"
283
 
                        "1:                     \n\t"
284
 
                                "movl (%0, %%eax), %%ebx        \n\t"
285
 
                                "movl 32(%0, %%eax), %%ebx      \n\t"
286
 
                                "movl 64(%0, %%eax), %%ebx      \n\t"
287
 
                                "movl 96(%0, %%eax), %%ebx      \n\t"
288
 
                                "addl $128, %%eax               \n\t"
289
 
                                "cmpl %3, %%eax                 \n\t"
290
 
                                " jb 1b                         \n\t"
291
 
 
292
 
                        "xorl %%eax, %%eax      \n\t"
293
 
 
294
 
                                ".balign 16             \n\t"
295
 
                                "2:                     \n\t"
296
 
                                "movq (%0, %%eax), %%mm0\n"
297
 
                                "movq 8(%0, %%eax), %%mm1\n"
298
 
                                "movq 16(%0, %%eax), %%mm2\n"
299
 
                                "movq 24(%0, %%eax), %%mm3\n"
300
 
                                "movq 32(%0, %%eax), %%mm4\n"
301
 
                                "movq 40(%0, %%eax), %%mm5\n"
302
 
                                "movq 48(%0, %%eax), %%mm6\n"
303
 
                                "movq 56(%0, %%eax), %%mm7\n"
304
 
                                MOVNTQ" %%mm0, (%1, %%eax)\n"
305
 
                                MOVNTQ" %%mm1, 8(%1, %%eax)\n"
306
 
                                MOVNTQ" %%mm2, 16(%1, %%eax)\n"
307
 
                                MOVNTQ" %%mm3, 24(%1, %%eax)\n"
308
 
                                MOVNTQ" %%mm4, 32(%1, %%eax)\n"
309
 
                                MOVNTQ" %%mm5, 40(%1, %%eax)\n"
310
 
                                MOVNTQ" %%mm6, 48(%1, %%eax)\n"
311
 
                                MOVNTQ" %%mm7, 56(%1, %%eax)\n"
312
 
                                "addl $64, %%eax                \n\t"
313
 
                                "cmpl %3, %%eax         \n\t"
314
 
                                "jb 2b                          \n\t"
 
279
    if(i>=BLOCK_SIZE/64)
 
280
        asm volatile(
 
281
            "xorl %%eax, %%eax    \n\t"
 
282
            ".balign 16        \n\t"
 
283
            "1:            \n\t"
 
284
                "movl (%0, %%eax), %%ebx     \n\t"
 
285
                "movl 32(%0, %%eax), %%ebx     \n\t"
 
286
                "movl 64(%0, %%eax), %%ebx     \n\t"
 
287
                "movl 96(%0, %%eax), %%ebx     \n\t"
 
288
                "addl $128, %%eax        \n\t"
 
289
                "cmpl %3, %%eax            \n\t"
 
290
                " jb 1b                \n\t"
 
291
 
 
292
            "xorl %%eax, %%eax    \n\t"
 
293
 
 
294
                ".balign 16        \n\t"
 
295
                "2:            \n\t"
 
296
                "movq (%0, %%eax), %%mm0\n"
 
297
                "movq 8(%0, %%eax), %%mm1\n"
 
298
                "movq 16(%0, %%eax), %%mm2\n"
 
299
                "movq 24(%0, %%eax), %%mm3\n"
 
300
                "movq 32(%0, %%eax), %%mm4\n"
 
301
                "movq 40(%0, %%eax), %%mm5\n"
 
302
                "movq 48(%0, %%eax), %%mm6\n"
 
303
                "movq 56(%0, %%eax), %%mm7\n"
 
304
                MOVNTQ" %%mm0, (%1, %%eax)\n"
 
305
                MOVNTQ" %%mm1, 8(%1, %%eax)\n"
 
306
                MOVNTQ" %%mm2, 16(%1, %%eax)\n"
 
307
                MOVNTQ" %%mm3, 24(%1, %%eax)\n"
 
308
                MOVNTQ" %%mm4, 32(%1, %%eax)\n"
 
309
                MOVNTQ" %%mm5, 40(%1, %%eax)\n"
 
310
                MOVNTQ" %%mm6, 48(%1, %%eax)\n"
 
311
                MOVNTQ" %%mm7, 56(%1, %%eax)\n"
 
312
                "addl $64, %%eax        \n\t"
 
313
                "cmpl %3, %%eax        \n\t"
 
314
                "jb 2b                \n\t"
315
315
 
316
316
#if CONFUSION_FACTOR > 0
317
 
        /* a few percent speedup on out of order executing CPUs */
318
 
                        "movl %5, %%eax         \n\t"
319
 
                                "2:                     \n\t"
320
 
                                "movl (%0), %%ebx       \n\t"
321
 
                                "movl (%0), %%ebx       \n\t"
322
 
                                "movl (%0), %%ebx       \n\t"
323
 
                                "movl (%0), %%ebx       \n\t"
324
 
                                "decl %%eax             \n\t"
325
 
                                " jnz 2b                \n\t"
326
 
#endif
327
 
 
328
 
                        "xorl %%eax, %%eax      \n\t"
329
 
                        "addl %3, %0            \n\t"
330
 
                        "addl %3, %1            \n\t"
331
 
                        "subl %4, %2            \n\t"
332
 
                        "cmpl %4, %2            \n\t"
333
 
                        " jae 1b                \n\t"
334
 
                                : "+r" (from), "+r" (to), "+r" (i)
335
 
                                : "r" (BLOCK_SIZE), "i" (BLOCK_SIZE/64), "i" (CONFUSION_FACTOR)
336
 
                                : "%eax", "%ebx"
337
 
                );
338
 
#endif
339
 
 
340
 
        for(; i>0; i--)
341
 
        {
342
 
                __asm__ __volatile__ (
 
317
    /* a few percent speedup on out of order executing CPUs */
 
318
            "movl %5, %%eax        \n\t"
 
319
                "2:            \n\t"
 
320
                "movl (%0), %%ebx    \n\t"
 
321
                "movl (%0), %%ebx    \n\t"
 
322
                "movl (%0), %%ebx    \n\t"
 
323
                "movl (%0), %%ebx    \n\t"
 
324
                "decl %%eax        \n\t"
 
325
                " jnz 2b        \n\t"
 
326
#endif
 
327
 
 
328
            "xorl %%eax, %%eax    \n\t"
 
329
            "addl %3, %0        \n\t"
 
330
            "addl %3, %1        \n\t"
 
331
            "subl %4, %2        \n\t"
 
332
            "cmpl %4, %2        \n\t"
 
333
            " jae 1b        \n\t"
 
334
                : "+r" (from), "+r" (to), "+r" (i)
 
335
                : "r" (BLOCK_SIZE), "i" (BLOCK_SIZE/64), "i" (CONFUSION_FACTOR)
 
336
                : "%eax", "%ebx"
 
337
        );
 
338
#endif
 
339
 
 
340
    for(; i>0; i--)
 
341
    {
 
342
        __asm__ __volatile__ (
343
343
#ifndef HAVE_MMX1
344
 
                PREFETCH" 320(%0)\n"
 
344
            PREFETCH" 320(%0)\n"
345
345
#endif
346
 
                "movq (%0), %%mm0\n"
347
 
                "movq 8(%0), %%mm1\n"
348
 
                "movq 16(%0), %%mm2\n"
349
 
                "movq 24(%0), %%mm3\n"
350
 
                "movq 32(%0), %%mm4\n"
351
 
                "movq 40(%0), %%mm5\n"
352
 
                "movq 48(%0), %%mm6\n"
353
 
                "movq 56(%0), %%mm7\n"
354
 
                MOVNTQ" %%mm0, (%1)\n"
355
 
                MOVNTQ" %%mm1, 8(%1)\n"
356
 
                MOVNTQ" %%mm2, 16(%1)\n"
357
 
                MOVNTQ" %%mm3, 24(%1)\n"
358
 
                MOVNTQ" %%mm4, 32(%1)\n"
359
 
                MOVNTQ" %%mm5, 40(%1)\n"
360
 
                MOVNTQ" %%mm6, 48(%1)\n"
361
 
                MOVNTQ" %%mm7, 56(%1)\n"
362
 
                :: "r" (from), "r" (to) : "memory");
363
 
                from = (const void *) (((const unsigned char *)from)+64);
364
 
                to = (void *) (((unsigned char *)to)+64);
365
 
        }
 
346
        "movq (%0), %%mm0\n"
 
347
        "movq 8(%0), %%mm1\n"
 
348
        "movq 16(%0), %%mm2\n"
 
349
        "movq 24(%0), %%mm3\n"
 
350
        "movq 32(%0), %%mm4\n"
 
351
        "movq 40(%0), %%mm5\n"
 
352
        "movq 48(%0), %%mm6\n"
 
353
        "movq 56(%0), %%mm7\n"
 
354
        MOVNTQ" %%mm0, (%1)\n"
 
355
        MOVNTQ" %%mm1, 8(%1)\n"
 
356
        MOVNTQ" %%mm2, 16(%1)\n"
 
357
        MOVNTQ" %%mm3, 24(%1)\n"
 
358
        MOVNTQ" %%mm4, 32(%1)\n"
 
359
        MOVNTQ" %%mm5, 40(%1)\n"
 
360
        MOVNTQ" %%mm6, 48(%1)\n"
 
361
        MOVNTQ" %%mm7, 56(%1)\n"
 
362
        :: "r" (from), "r" (to) : "memory");
 
363
        from = (const void *) (((const unsigned char *)from)+64);
 
364
        to = (void *) (((unsigned char *)to)+64);
 
365
    }
366
366
 
367
367
#endif /* Have SSE */
368
368
#ifdef HAVE_MMX2
369
369
                /* since movntq is weakly-ordered, a "sfence"
370
 
                 * is needed to become ordered again. */
371
 
                __asm__ __volatile__ ("sfence":::"memory");
 
370
         * is needed to become ordered again. */
 
371
        __asm__ __volatile__ ("sfence":::"memory");
372
372
#endif
373
373
#ifndef HAVE_SSE
374
 
                /* enables to use FPU */
375
 
                __asm__ __volatile__ (EMMS:::"memory");
 
374
        /* enables to use FPU */
 
375
        __asm__ __volatile__ (EMMS:::"memory");
376
376
#endif
377
 
        }
378
 
        /*
379
 
         *      Now do the tail of the block
380
 
         */
381
 
        if(len) small_memcpy(to, from, len);
382
 
        return retval;
 
377
    }
 
378
    /*
 
379
     *    Now do the tail of the block
 
380
     */
 
381
    if(len) small_memcpy(to, from, len);
 
382
    return retval;
383
383
}
384
384
 
385
385