기억창고

mudflap 라이브러리는 gcc 내에 포함된 메모리 검사 기능으로
포인터를 통한 메모리 접근 시 이를 검사하는 코드를 원래의 코드 내에 직접 삽입하는 방식이다.
mudflap은 gcc와 통합되어 있기 때문에 코드를 생성하는 과정 내에서
포인터를 통한 메모리 접근을 인식하면 자동으로 그에 대한 검사 코드를 만들 수 있다.

기본적인 동작 방식은 미리 할당된 메모리 영역에 대한 정보를 등록하여 데이터베이스를 구성해 두고
포인터를 이용한 메모리 접근 시 등록된 메모리 영역에 대한 접근인지를 체크하는 식이다.

전역 변수 및 문자열 상수, 명령행 인자, 환경 변수 등은 프로그램 실행 시작 시 자동으로 등록되며
스택 변수의 경우 해당 block에 진입/탈출 시 동적으로 등록/해제된다.
help 변수의 경우도 heap 할당 함수를 (malloc, calloc 등) wrapping하여
해당 영역에 대한 정보를 등록하도록 되어 있다.

이러한 등록 과정은 __mf_register() 함수가 수행하는데
기본적으로 메모리 영역의 시작 주소, 크기, 객체 타입, 이름 등의 정보가 저장된다.
여기서 객체 타입은 heap, stack, static 등을 구분하기 위한 정수값이며
객체 이름은 "파일명:줄번호:행번호 (함수명) 변수명"의 형태이다.

간단한 예제를 살펴보기로 하자.

p 변수는 원래의 msg 영역을 벗어난 메모리 영역에 접근했다.
이 경우 사실은 msg 아래에는 buf가 할당되어 있으니 메모리 자체로는 접근이 가능한 구역이긴 하다.
하지만 mudflap은 코드에서 buf에 접근하지 않았으므로 buf를 등록하지 않기 때문에
이러한 종류의 메모리 접근도 오류로 잡아낼 수 있다.

mudflap을 이용하도록 컴파일하려면 -fmudflap 옵션을 추가해야 한다.
(multi-thread 프로그램에서 이용할 경우에는 mudflapth 옵션을 대신 이용해야 한다.)
이에 관련된 builtin spec들을 살펴보면 다음과 같다.

cpp 실행 시에는 _MUDFLAP 매크로를 정의하고 mf-runtime.h 파일을 #include한다.
cc1 실행 시에는 문자열/메모리 관련 함수들을 최적화하지 않고 mudflap을 통하여 실행하기 위해
builtin 함수를 사용하지 않도록 하고 동일한 문자열 상수로 별도로 관리하기 위해 병합하지 않는다.
링크 시에는 main 함수를 wrapping하기 위해 실행 파일 내의 심볼들도 dynamic symbol table을 통해 공개하며
특히 static 빌드 시에는 동적 메모리 함수들도 관리하기 위해 모두 wrapping한다.

다음과 같이 컴파일 후 실행하면 아래와 같은 메시지를 출력할 것이다.
(-fmudflap 옵션을 주고 맨 뒤에 -lmudflap을 링크하도록 지정해야 한다.)
우분투의 경우 libmudflap0 와 libmudflap0-dev 패키지를 설치하면 테스트해 볼 수 있다.

메시지는 메모리 쓰기 접근 시 오류가 났음을 보여주며 (check/write)
접근 주소 및 크기와 소스 코드에서의 위치까지 표시해 준다.
그 아래는 stack backtrace 정보를 출력한 것이다.
그 아래는 접근한 영역의 근처에 있는 등록된 메모리 영역 정보를 표시하는 것으로
1 바이트 뒤에 "test.c:6:8 (main) msg" 객체가 있다는 것을 보여준다.
해당 객체의 메모리 위치는 bounds 속성에서 볼 수 있고, 객체 타입(area)은 stack이다.

그럼 mudflap은 어떻게 스택에 할당된 메모리 영역을 관리할 수 있을까?
가장 기본적으로는 포인터에 대한 대입 (assignment) 연산이 일어나는지 확인한 후
해당 (즉, 포인터에 대입된) 메모리 영역을 __mf_register() 함수로 등록하는 것이다.

gcc는 코드 생성 과정에서 포인터를 통한 스택 접근을 확인하면
다음과 같은 식으로 (C++의 예외 처리 방식을 이용하도록) 코드를 변경한다.
위에서 코드 컴파일 시 -fdump-tree-mudflap1 옵션을 주면 이 과정을 볼 수 있다.

위에서 보듯이 해당 코드는 try-finally 블록으로 감싸지고
코드의 시작과 finally 부분에 msg를 등록/해제하는 register/unregister 함수가 추가되었다.
참고로 3번째 인자로 주어진 3이라는 값은 해당 객체가 stack 타입 임을 나타낸다. (__MF_TYPE_STACK)

위의 코드는 아직 mudflap 처리가 완전히 끝난 것이 아니라서 빠져있지만
최종적으로 메모리를 역참조(dereference) 하는 부분에는 메모리 접근을 검사하는 코드가 추가될 것이다.
GNU C 확장 기능인 statement expression을 이용하여 표현하면 p->f 식의 메모리 접근은
({ __mf_check(p, sizeof(*p), __MF_CHECK_WRITE, location); p; })->f 와 같은 형태로 바뀐다.
실제로는 lookup cache 검사 및 필드 f의 위치로 인해 이와는 약간 다른 형태의 코드가 생성된다.

또한 string이나 memory 관련 표준 함수들도 mudflap에 의해 wrapping되어
실제 함수 수행 전에 먼저 메모리 영역에 대한 검사가 이루어진다.
다음은 memcpy 함수에 대한 wrapper 루틴이다.

여기서 실제 검사하는 MF_VALIDATE_EXTENT 매크로에서 수행하는데
이는 다음과 같이 정의되어 있다.

먼저 주어진 메모리 영역을 최근에 참조한 캐시 (__mf_lookup_cache)에서 찾아보는데
찾지못한다면 (__MF_CACHE_MISS_P()가 true를 반환) __mf_check()를 호출하여 등록된 전체 객체를 모두 찾아본다.
이 때 설정에 따라 read 접근인 경우 검사를 수행하지 않을 수도 있다. (-ignore-reads)

동적 메모리 함수의 경우에는 마찬가지로 wrapper 함수를 만들어서 내부적으로 실제 함수를 호출한 뒤
결과로 얻어진 영역을 __mf_register() 함수를 통해 자동으로 등록하도록 되어 있다.

하지만 이렇게 하더라도 모든 메모리 정보를 추적할 수는 없는 경우가 있다.
예를 들어 mudflap을 이용하지 않고 빌드된 외부 라이브러리를 이용하는 경우
해당 라이브러리 함수 내에서 할당된 동적 메모리 등의 경우는 mudflap에서 알아낼 수가 없다.

이 경우 프로그램에서 해당 메모리 접근 시 violation이 발생할 수 있는데
(혹은 어떤 이유로든 mudflap이 인식하지 못하는 정상적인 영역에 접근 시에도 마찬가지다)
이런 상황에 대처하기 위해 mudflap이 제공하는 몇 가지 heuristic을 이용할 수 있다.
이는 MUDFLAP_OPTIONS라는 환경 변수를 다음 중 하나로 설정하면 된다.

• -heur-proc-maps : 리눅스에서 제공하는 /proc/<pid>/maps 파일에 등록된 영역이면 허가한다.
• -heur-stack-bound : 현재 할당된 스택 영역 내의 접근은 허가한다.
• -heur-start-end : 프로그램의 text/data/bss 영역 내의 접근은 허가한다.
• -heur-argv-environ : 프로그램 실행 시 주어진 argv, env 배열에 대한 접근은 허가한다. (기본값: enable)

이 외에도 MUDFLAP_OPTIONS는 mudflap의 전반적인 동작 모드를 변경하거나
violation 발생 시 동작 변경 및 추가적인 정보를 표시할 수 있는 등의 여러가지 옵션을 설정할 수 있다.
옵션의 전체 목록은 mudflap을 이용해 빌드된 프로그램 실행 시 MUDFLAP_OPTIONS에 -help를 설정하면 볼 수 있다.


=== 참고 문헌 ===

• http://gcc.fyxm.net/summit/2003/mudflap.pdf
• http://gcc.gnu.org/wiki/Mudflap_Pointer_Debugging

http://www.slideshare.net/codenavy/ss-9303139

읽어보면 좋은 자료.

참고가 될듯..

출처 : http://www.mimul.com/pebble/default/2012/05/30/1338342349153.html

개요

OpenMP는 여러개의 프로세스가 공유된 메모리를 참조하는 환경에서 다중 스레드 병렬 프로그래밍을 위한 표준 스펙이다. 여기에서 제공하는 API를 통해 사용자들은 어플리케이션의 성능 향상을 얻을 수 있게 된다.



OpenMP의 주요 동기요인은 성능, 확장성, 이식성, 표준성을 목표로 한다. 그리고 C, C++(#으로 시작), Fortran(90에서는 !$로 시작)을 지원하고 있다.
역사로는 1997년에 Fortran 1.0가 최초로 나왔고 그 후 1998년 C/C++ 1.0이 출시, 2005년에 OpenMP 2.5가, 2008년에 OpenMP 3가 나와서 현재에 이르고 있다.
OpenMP를 주로 사용하는 방법은 프로파일링을 통해 시간을 많이 차지하는 부분을 식별하고 해당 프로그램에서 사용되는 의존성, 데이터의 유효 범위를 예측한 다음 지시어의 설정을 통해 병렬 처리를 하여 성능 향상을 얻는 방식으로 진행된다.

구성

1) Directives(컴파일러 지시자)
쓰레드 사이의 작업 분담, 통신, 동기화를 담당을 한다. 컴파일러가 지시자를 참고하여 다중 쓰레드 코드를 생성하게 된다.
Work-Sharing 지시자는 상세히 설명할 필요가 있어서 아래에 새로운 단락으로 빼서 설명하고 여기서는 동기화, 데이터 유효 범위 지시자를 설명한다. OpenMP 프로그래밍은 컴파일러가 모두 알아서 처리하는게 아니라 동기화 및 의존성 제거 등의 작업은 사용자가 직접 소스코드에 기술해 주어야 한다는 점에서 병렬프로그래밍이 어렵게 인식되는 부분중에 하나다.

- 상호 배제 동기화

• critical : 병렬영역 안에서 critical section을 지정하면 그 영역은 하나의 스레드에서 실행 된다.
• atomic : 하나의 스칼라 변수를 경신하는 지정된 단일 문장(single statement)에 대해 여러 스레드가 접근하는 것을 방지한다. mini-critical section의 역할과 비슷하다.
• flush : 하나의 메모리에 여러 개의 스레드가 경합을 벌이는 경우 그 정합성을 유지시켜 주는 지시어

- 이벤트 동기화

• barrier : 모든 스레드들이 barrier에 도달할 때까지 대기하게 된다.
• ordered : ordered section 내부의 루프 실행을 순차적으로 진행한다.
• master : master section을 마스터 쓰레드에서만 실행시킨다.
• taskwait : 모든 task가 taskwait에 도달할 때까지 대기한다.

- 데이터의 유효 범위 지시자

• private : 지정된 변수를 스레드끼리 공유하는 것 방지한다. 주로 스칼라값, 여러 쓰레드들이 동시에 접근해서 쓰기를 할경우 사용.
• shared : 지정된 변수를 모든 스레드가 공유하도록 한다. 디폴트.
• default : private 또는 shared로 선언되지 않은 변수의 기본적인 유효범위 지정한다.
• firstprivate : private 변수처럼 각 쓰레드에 개별적으로 변수 생성하고 각 스레드 마다 순차 영역에서 가져온 값으로 초기화한다.
• lastprivate : private 변수처럼 각 스레드에 개별적으로 변수 생성하고 순차 실행에서 마지막 계산에 해당되는 값. 즉, 마지막 반복실행의 값을 마스터 스레드에게 넘겨준다.
• reduction : reduction 변수는 shared이고 다중 스레드에서 병렬로 수행된 계산 결과를 환산해 최종 결과를 마스터 스레드로 내 놓는다.
• schedule : 작업의 균등 분배를 위해 schedule 을 사용한다.

2) Runtime Library
병렬화에 직접 참여는 하지 않지만 실행 환경에서 병렬 매개 변수(참여 스레드의 개수, 번호 등)의 설정과 조회를 통해 병렬화 정보를 변경 조회할 수 있다.

• omp_set_num_threads : 병렬 영역에서 사용할 스레드 개수 설정
• omp_get_num_threads() : 병렬 영역 안에서 호출되어 생성된 스레드의 개수를 리턴
• omp_get_thread_num() : 병렬 영역 안에서 생성된 스레드들의 ID를 리턴
• omp_get_max_threads() : 병렬 영역에서 사용 가능한 최대 스레드 개수 리턴
• omp_set_nested() : nested 병렬성 지원 여부 결정
• omp_set_dynamic() : 순차 영역에서 호출되어 이어지는 병렬 영역 들의 스레드 개수 할당을 동적으로 수행
• omp_get_nested() : 호출되는 시점의 nested 병렬성 설정 여부 확인
• omp_get_dynamic() : 스레드 할당 방식이 동적인지 확인
• omp_in_parallel() : 호출된 지점이 순차 영역인지 병렬 영역인지 확인
• omp_get_num_procs() : 프로그램에서 사용 가능한 물리적 프로세서의 총 개수 확인

3) Environment Variables
Runtime Library와 중복되는 부분이 많지만 우선순위는 동일한 지시자를 반복 사용했을 경우 Runtime Library가 우선된다. 주요한 일은 실행 시스템의 병렬 매개 변수(스레드 개수 등)를 설정해 실행시에 제어를 한다.

• OMP_NUM_THREADS : 병렬영역에서 사용 가능한 최대 스레드 개수 지정
• OMP_SCHEDULE : schedule type이 runtime으로 지정된 루프들에게 scheduling 방식 지정
• OMP_DYNAMIC : 스레드 개수의 동적할당 여부 결정
• OMP_NESTED : nested 병렬성 지원 여부 결정

프로그래밍 모델

1) Fork-Join 모델
쓰레드가 병렬 구문를 만나면 쓰레드는 그 자신을 포함한 추가적인 쓰레드(0개 이상의)로 이루어진 쓰레드 팀을 만든다(Fork). 병렬 구문를 만난 쓰레드는 팀의 마스터 쓰레드를 호출 하게 되고(Join) 다른 쓰레드들은 팀의 slave 쓰레드라고 불리어진다.

Work-Sharing 모델

같은 작업을 쓰레드별로 실행하는 것이 아니라 작업을 분할해서 쓰레드별로 나누어서 실행하는 것을 말한다.

1) for
바로 뒤에 오는 for 루프의 반복 실행을 쓰레드에 분배한다. 그리고 루프 끝에 암시적 장벽(동기화)이 존재한다. 이를 피할려면 nowait 사용하면 된다.
데이터 병렬화시에 활용된다.

#include <stdio.h>
#include <omp.h>

int main(int argc, char *argv[]) {
  int i;
#pragma omp parallel for
  for(i=0; i<10; i++) {
    printf("[%d-%d] Hello World\n", omp_get_thread_num(), i);
  }
   return 0;
}
> gcc -fopenmp -o for_hello for_hello.c
> ./for_hello
[0-0] Hello World
[0-1] Hello World
[0-2] Hello World
[2-6] Hello World
[2-7] Hello World
[2-8] Hello World
[3-9] Hello World
[1-3] Hello World
[1-4] Hello World
[1-5] Hello World

2) sections
독립된 여러 개 작업을 각 스레드에 분산 실행한다. 그리고 sections 구문 끝에 암시적 장벽(동기화)이 존재하고 이를 피할려면 nowait 사용하면 된다.
기능적 분할에 이용된다.

#include <stdio.h>
#include <omp.h>

int main(int argc, char *argv[]) {
#pragma omp parallel
#pragma omp sections
  {
#pragma omp section
    {
      printf("[%d] Hello \n", omp_get_thread_num());
    }
#pragma omp section
    {
      printf("[%d] World \n", omp_get_thread_num());
    }
  }
  return 0;
}
> gcc -fopenmp -o section_hello section_hello.c
> ./section_hello
[0] Hello 
[3] World 

3) single
병렬 영역 내부에서 하나의 스레드만을 이용해 작업 수행한다. single 지시어자 가장 먼저 접근한 스레드에 작업 할당된다. single 구문 끝에 암시적 장벽(동기화)이 존재한다.마찬가지로 이를 피하기 위해서는 nowait 사용하면 된다.
병렬 영역 내에서의 입/출력 수행에 주로 사용된다.

#include <stdio.h>
#include <omp.h>

int main(int argc, char *argv[]) {
#pragma omp parallel
 {
#pragma omp single
    {
      printf("[%d] Hello \n", omp_get_thread_num());
      
    }
    printf("[%d] World \n", omp_get_thread_num());
  }
  return 0;
}

> gcc -fopenmp -o single_hello single_hello.c
> ./single_hello
[3] Hello 
[3] World 
[2] World 
[1] World 
[0] World 

4) Task
OpenMP 버전 3.0 이상부터 추가된 지시자며, 수행할 작업을 한번의 호출로 진행되는 작업이나 한번의 구문으로 실행 가능한 작업 단위 나눈다. 태스트 실행은 작업 스케쥴링이 적용된다.

#include <stdio.h>
#include <omp.h>

int main(int argc, char *argv[]) {
#pragma omp parallel
  {
#pragma omp single
    {
#pragma omp task
      {
        printf("Hello ");
      }
#pragma omp task
      {
        printf("World ");
      }
#pragma omp taskwait
      printf("\nThanks! ");
    }
  }
  printf("\n");
  return 0;
}

> gcc -fopenmp -o task_hello task_hello.c
> ./task_hello 
Hello World 
Thanks! 

추후에는 mysql++ 라이브러리를 활용해서 MySQL Benchmark 클라이언트 성능 개선 예제를 올려볼까 합니다.

[참조 사이트]

• C언어: OpenMP를 이용한 멀티 쓰레드 프로그래밍 HOWTO #1
• OpenMP
• OpenMP를 이용한 병렬 프로그래밍

Responses[1] 

Posted by 미물 on May 30, 2012 10:45:49 AM KST #

- backtrace 출력 하는 방법.

http://jh4hj.tistory.com/355  

-make 의존성

http://jh4hj.tistory.com/entry/%EC%88%A8%EA%B2%A8%EC%A7%84-1%EC%9D%B8%EC%B9%98%EC%9D%98-%EC%9D%98%EC%A1%B4%EC%84%B1%EC%9D%84-%EC%B0%BE%EC%95%84%EC%84%9C-make

- 메모리 디버깅

http://jh4hj.tistory.com/entry/%EB%A9%94%EB%AA%A8%EB%A6%AC-%EB%94%94%EB%B2%84%EA%B9%85%EC%9D%84-%EC%9C%84%ED%95%9C-%EC%B9%9C%EA%B5%AC

출처 : http://www.joinc.co.kr/modules/moniwiki/wiki.php/article/gdbm

프로그램 분석중 gdbm_exists 라는 함수를 발견 했습니다. 

뭔가 했더니 이런게 있군요... ㄷㄷㄷ

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <gdbm/gdbm.h>

const int FALSE = 0;
const int TRUE  = 1;


int main(int argc, char **argv)
{
    datum key_data;
    datum value_data;
    datum return_data;

    char cmd_char;
    int done = FALSE;

    GDBM_FILE dbf;


    int block_size = 0;

    int temp;

    char key_line[80];
    char value_line[255];

    key_data.dptr = NULL;
    value_data.dptr = value_line;

    if (access("/tmp/my_dic", F_OK) != 0)
    {
        printf( "사전 DB 파일이 존재 하지 않습니다"
                "영어 사전  DB 파일을 새로 만들겠습니까 (y/n)? ");
        cmd_char = getchar();

        while(1)
        {
            if (cmd_char != '')
            {
                char temp;
                do
                    temp=getchar();
                while (temp != '' && temp != EOF);
            }

            if (cmd_char == EOF) cmd_char = 'n';
            switch(cmd_char)
            {
                case 'y':
                    dbf = gdbm_open ("/tmp/my_dic", block_size, GDBM_WRCREAT|GDBM_FAST, 00664, NULL);
                    if (dbf == NULL)
                    {
                        perror("db file open error : ");
                        exit(0); 
                    }
                    break;
                case 'n':
                    return 1;
                    break;
            }

            if (cmd_char == 'y')
                break;
        }

    }
    else
    {
        dbf = gdbm_open ("/tmp/my_dic", block_size, GDBM_READER|GDBM_WRITER, 00664, NULL);
        if (dbf == NULL)
        {
            perror("db file open error : ");
            exit(0);
        }
    }


    printf("주소 관리 프로그램입니다. "
           "사용법이 궁금하시면 ? 를 입력하세요");
    // 사용자의 키보드 입력문자열을 받아서 필요한 
    // 행동을 취한다.
    while(!done)
    {
        printf("com -> ");
        cmd_char = getchar();

        if (cmd_char != '')
        {
            char temp;
            do
                temp = getchar();
            while (temp != '' && temp != EOF);
        }
        if (cmd_char == EOF) cmd_char = 'q';

        switch (cmd_char)
        {
            case 'q':
                done = TRUE;
                break;
            case '?':
                printf("i -- insert data"
                       "f -- fetch data"
                       "c -- data num"
                       "d -- data delete"
                       "q -- quit");
                break;

            case '':
                printf("");
                break;
            case 'i':
                if (key_data.dptr != NULL) free(key_data.dptr);
                printf("Key -> ");
                fgets (key_line, 80, stdin);
                key_line[strlen(key_line) - 1] = '0';

                key_data.dptr = key_line;
                key_data.dsize = strlen(key_line) + 1;

                printf("Value -> ");
                fgets(value_line, 255, stdin); 

                value_data.dsize = strlen(value_line) + 1;
                if (gdbm_store (dbf, key_data, value_data, GDBM_REPLACE) != 0)
                    printf("Item no inserted ");
                printf("");
                key_data.dptr = NULL;
                break;

            case 'f':
                if (key_data.dptr != NULL) free(key_data.dptr);
                printf("Key -> ");
                fgets (key_line, 80, stdin);
                key_line[strlen(key_line) -1] = 0;
                key_data.dptr = key_line;
                key_data.dsize = strlen(key_line) + 1;

                return_data = gdbm_fetch(dbf, key_data);
                if (return_data.dptr != NULL)
                {
                    printf("data -> %s", return_data.dptr);
                    free(return_data.dptr);
                }

                else
                    printf("No Such item found. ");
                key_data.dptr = NULL;
                break;
            case 'c':
                temp = 0;

                if (key_data.dptr != NULL) free (key_data.dptr);
                return_data =  gdbm_firstkey(dbf);
                while(return_data.dptr != NULL)
                {
                    temp ++;
                    key_data = return_data;
                    return_data = gdbm_nextkey(dbf, key_data);
                    free(key_data.dptr);
                }
                printf("%d 개의 자료가 있습니다", temp);
                key_data.dptr = NULL;
                break;

            case 'a':
                key_data = gdbm_firstkey(dbf);
                if (key_data.dptr == NULL)
                {
                    printf("No one tiem found");
                    break;
                }
                else
                {
                    printf("%s => ", key_data.dptr);
                    return_data = gdbm_fetch(dbf, key_data);
                    printf("%s", return_data.dptr);
                    free(return_data.dptr);
                }
                while(1)
                {
                    return_data = gdbm_nextkey(dbf, key_data);
                    if (return_data.dptr != NULL)
                    {
                        free(key_data.dptr);
                        key_data = return_data;
                        printf("%s => ", key_data.dptr);
                        return_data = gdbm_fetch(dbf, key_data);
                        printf("%s", return_data.dptr);
                        free(return_data.dptr);
                    }
                    else
                    {
                        printf("No such item found.");
                        break;
                    }
                }
                key_data.dptr = NULL;
                break;

            case 'd':
                if (key_data.dptr != NULL) free (key_data.dptr);

                printf("Key -> ");
                fgets (key_line, 80, stdin);
                key_line[strlen(key_line) -1] = 0;
                key_data.dptr = key_line;
                key_data.dsize = strlen(key_line) + 1;
                if(gdbm_delete (dbf, key_data) != 0)
                    printf("Item not found or deleted");
                key_data.dptr = NULL;
                break;
        }
    }

    printf("bye bye");
    return 0;
}