source: contrib/API/lib/fast_memcpy.c

/*
 * This file is part of uniaud.dll.
 *
 * based on xine project memcpy.c
 *
 * These are the MMX/MMX2/SSE optimized versions of memcpy
 *
 * This code was adapted from Linux Kernel sources by Nick Kurshev to
 * the mplayer program. (http://mplayer.sourceforge.net)
 *
 * Miguel Freitas split the #ifdefs into several specialized functions that
 * are benchmarked at runtime by xine. Some original comments from Nick
 * have been preserved documenting some MMX/SSE oddities.
 * Also added kernel memcpy function that seems faster than glibc one.
 *
 * Copyright (c) 2010 Mensys BV
 * Copyright (c) 2007 Vlad Stelmahovsky aka Vladest
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and the GNU General Public License along with this library.
 * If not, see <http://www.gnu.org/licenses/>.
 */
#include <os2.h>
#include <stdio.h>

#include "fastmemcpy.h"
#include "internal.h"

void *(* fast_memcpy)(void *to, const void *from, size_t len);

void * _memcpy(void * to, const void * from, size_t len);
void * sse_memcpy(void * to, const void * from, size_t len);
void * mmx_memcpy(void * to, const void * from, size_t len);
void * mmx2_memcpy(void * to, const void * from, size_t len);

#ifndef FASTMEMCPY_TEST

int init_fast_memcpy(int mm_flgs)
{
        if (mm_flgs & MM_MMXEXT) { // MMXEXT
                fast_memcpy = mmx2_memcpy;
                if (DebugMode) printf("Using MMXEXT for fastmemcpy\n");
                return 0;
        }
        if (mm_flgs & MM_MMX) { // MMX
                fast_memcpy = mmx_memcpy;
                if (DebugMode) printf("Using MMX for fastmemcpy\n");
                return 0;
        }
        if (mm_flgs & MM_SSE) { // SSE
                fast_memcpy = sse_memcpy;
                if (DebugMode) printf("Using SSE for fastmemcpy\n");
                return 0;
        }
        fast_memcpy = _memcpy;
        if (DebugMode) printf("No accelerated fastmemcpy\n");

        return 0;
}

#else

#define INCL_DOSMISC

#include <os2.h>
#include <stdlib.h>
#include "uniaud.h"

#define BUFFER_SIZE 1024*1024

int main()
{
        int x;
        int count = 500;
        char *src_buffer;
        char *dst_buffer;
        ULONG start_time, end_time;
        int mm_flags;

        mm_flags = mm_support();

        printf("mm_flags=%x, size: %d, count: %d\n", mm_flags, BUFFER_SIZE, count);

        src_buffer = malloc(BUFFER_SIZE);
        dst_buffer = malloc(BUFFER_SIZE);

        // no optimised memcpy
        fast_memcpy = _memcpy;
        printf("\nTiming _memcpy...\n");
        DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &start_time, sizeof(ULONG));
        for(x = 0; x < count; x++) {
                fast_memcpy(dst_buffer, src_buffer, BUFFER_SIZE);
        }
        DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &end_time, sizeof(ULONG));
        printf("no optimised: %d ms\n", end_time - start_time);

        if (mm_flags & MM_MMXEXT) {
                // mmx2 memcpy
                fast_memcpy = mmx2_memcpy;
                printf("\nTiming mmx2_memcpy...\n");
                DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &start_time, sizeof(ULONG));
                for(x = 0; x < count; x++) {
                        fast_memcpy(dst_buffer, src_buffer, BUFFER_SIZE);
                }
                DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &end_time, sizeof(ULONG));
                printf("mmx2: %d ms\n", end_time - start_time);
        }

        if (mm_flags & MM_MMX) {
                // mmx memcpy
                fast_memcpy = mmx_memcpy;
                printf("\nTiming mmx_memcpy...\n");
                DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &start_time, sizeof(ULONG));
                for(x = 0; x < count; x++) {
                        fast_memcpy(dst_buffer, src_buffer, BUFFER_SIZE);
                }
                DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &end_time, sizeof(ULONG));
                printf("mmx: %d ms\n", end_time - start_time);
        }

        if (mm_flags & MM_SSE) {
                // sse memcpy
                fast_memcpy = sse_memcpy;
                printf("\nTiming sse_memcpy...\n");
                DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &start_time, sizeof(ULONG));
                for(x = 0; x < count; x++) {
                        fast_memcpy(dst_buffer, src_buffer, BUFFER_SIZE);
                }
                DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &end_time, sizeof(ULONG));
                printf("sse: %d ms\n", end_time - start_time);
        }
        return(0);
}


#endif