Memcpy문제풀이

오류를 내뱉더니 죽었습니다¨。ōxō

// compiled with : gcc -o memcpy memcpy.c -m32 -lm
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/mman.h>
#include <math.h>

unsigned long long rdtsc(){
        asm("rdtsc");
}

char* slow_memcpy(char* dest, const char* src, size_t len){
    int i;
    for (i=0; i<len; i++) {
        dest[i] = src[i];
    }
    return dest;
}

char* fast_memcpy(char* dest, const char* src, size_t len){
    size_t i;
    // 64-byte block fast copy
    if(len >= 64){
        i = len / 64;
        len &= (64-1);
        while(i-- > 0){
            __asm__ __volatile__ (
            "movdqa (%0), %%xmm0\n"
            "movdqa 16(%0), %%xmm1\n"
            "movdqa 32(%0), %%xmm2\n"
            "movdqa 48(%0), %%xmm3\n"
            "movntps %%xmm0, (%1)\n"
            "movntps %%xmm1, 16(%1)\n"
            "movntps %%xmm2, 32(%1)\n"
            "movntps %%xmm3, 48(%1)\n"
            ::"r"(src),"r"(dest):"memory");
            dest += 64;
            src += 64;
        }
    }

    // byte-to-byte slow copy
    if(len) slow_memcpy(dest, src, len);
    return dest;
}

int main(void){

    setvbuf(stdout, 0, _IONBF, 0);
    setvbuf(stdin, 0, _IOLBF, 0);

    printf("Hey, I have a boring assignment for CS class.. :(\n");
    printf("The assignment is simple.\n");

    printf("-----------------------------------------------------\n");
    printf("- What is the best implementation of memcpy?        -\n");
    printf("- 1. implement your own slow/fast version of memcpy -\n");
    printf("- 2. compare them with various size of data         -\n");
    printf("- 3. conclude your experiment and submit report     -\n");
    printf("-----------------------------------------------------\n");

    printf("This time, just help me out with my experiment and get flag\n");
    printf("No fancy hacking, I promise :D\n");

    unsigned long long t1, t2;
    int e;
    char* src;
    char* dest;
    unsigned int low, high;
    unsigned int size;
    // allocate memory
    char* cache1 = mmap(0, 0x4000, 7, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    char* cache2 = mmap(0, 0x4000, 7, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    src = mmap(0, 0x2000, 7, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

    size_t sizes[10];
    int i=0;

    // setup experiment parameters
    for(e=4; e<14; e++){ // 2^13 = 8K
        low = pow(2,e-1);
        high = pow(2,e);
        printf("specify the memcpy amount between %d ~ %d : ", low, high);
        scanf("%d", &size);
        if( size < low || size > high ){
            printf("don't mess with the experiment.\n");
            exit(0);
        }
        sizes[i++] = size;
    }

    sleep(1);
    printf("ok, lets run the experiment with your configuration\n");
    sleep(1);

    // run experiment
    for(i=0; i<10; i++){
        size = sizes[i];
        printf("experiment %d : memcpy with buffer size %d\n", i+1, size);
        dest = malloc( size );

        memcpy(cache1, cache2, 0x4000);     // to eliminate cache effect
        t1 = rdtsc();
        slow_memcpy(dest, src, size);       // byte-to-byte memcpy
        t2 = rdtsc();
        printf("ellapsed CPU cycles for slow_memcpy : %llu\n", t2-t1);

        memcpy(cache1, cache2, 0x4000);     // to eliminate cache effect
        t1 = rdtsc();
        fast_memcpy(dest, src, size);       // block-to-block memcpy
        t2 = rdtsc();
        printf("ellapsed CPU cycles for fast_memcpy : %llu\n", t2-t1);
        printf("\n");
    }

    printf("thanks for helping my experiment!\n");
    printf("flag : ----- erased in this source code -----\n");
    return 0;
}

앞에서 experiment5에서 fast_memcpy 구간에서

오류가 생겨 그 뒷부분이 끊겨 아래 구간이 모두

통과가 돼야 키값을 구할 수가 있습니다.

// run experiment
    for(i=0; i<10; i++){ //
        size = sizes[i];
        printf("experiment %d : memcpy with buffer size %d\n", i+1, size);
        dest = malloc( size ); //

        memcpy(cache1, cache2, 0x4000);     // 
        t1 = rdtsc(); //
        slow_memcpy(dest, src, size);       // 
        t2 = rdtsc();
        printf("ellapsed CPU cycles for slow_memcpy : %llu\n", t2-t1);

        memcpy(cache1, cache2, 0x4000);     
        t1 = rdtsc();
        fast_memcpy(dest, src, size);       // 
        t2 = rdtsc();
        printf("ellapsed CPU cycles for fast_memcpy : %llu\n", t2-t1);
        printf("\n");
    }

    printf("thanks for helping my experiment!\n");
    printf("flag : ----- erased in this source code -----\n");
    return 0;
}

1. 입력받은 횟수만큼 10번 진행

2. 정해준 사이즈만큼 동적으로 메모리 할당하고 이는 dest 저장

3. rdtsc()는 정확한 시간을 측정하는 함수로 느린 메모리 복사를 진행한 시간 구하고 t1에 저장

4. t2 또한 빠른 메모리 복사를 진행한 시간이 들어간다.

5. 느린 메모리 복사와 빠른 메모리 복사는 각각 바이트 단위, 블록 단위 복사를 진행.

→ 해결책 : 우선 느린 메모리 복사 함수와 빠른 메모리 복사가 정의된 함수

부분으로 이동해서 함수를 파악해야 할 것입니다.

__asm__ __volatile__ (
"movdqa (%0), %%xmm0\n"
"movdqa 16(%0), %%xmm1\n"
"movdqa 32(%0), %%xmm2\n"
"movdqa 48(%0), %%xmm3\n"
"movntps %%xmm0, (%1)\n"
"movntps %%xmm1, 16(%1)\n"
"movntps %%xmm2, 32(%1)\n"
"movntps %%xmm3, 48(%1)\n"
::"r"(src),"r"(dest):"memory");

movdqa : 정렬된 더블 쿼드 워드 이동

소스 피어 연산자 (두 번째 피연산자)의

이중 쿼드 워드를 대상 피연산자

(첫 번째 피연산자)로 이동합니다.

​

이 명령어는 더블 쿼드 워드를

XMM 레지스터와 128비트

메모리 위치 간에 또는 두 개의

​

XMM 레지스터 간에 이동하는

데 사용할 수 있습니다.

소스 또는 대상 피연산자가

​

메모리 피연산자 인 경우

피연산자는 16바이트 경계에 정렬되어야 하면 그렇지 않으면 일반 보호 예외(#GP)가 생성.

​

movntps : 비 임시 힌트를 사용해 포장된 단일 정밀도 부동 소수점 값 저장

비 휘발성 힌트를 사용해 소스 피연산자의 압축된 부동 소수점 값을 대상

피연산자로 이동해 메모리에 쓰는 동안 데이터 캐싱을 방지합니다.

​

movdqa에서 mov가 값을 이동시키는 명령인데 dq가 더블

쿼드인듯합니다. 이 명령어는 16바이트 경계에 정렬되지

않으면 예외가 발생하고 피연산자인 dest의 주소가 16바이트

단위로 만들어준다면 16바이트 경계에 정렬되어 해결될 것입니다.

​

자 그리고 gdb를 사용해서 디버깅으로 키값을 받아 챙겨봅시다 ㅋㅅㅋ

스샷. 6