문서는 완성된게 아니며, 틀린 내용이 있을 수 있습니다. 수정해야 할 부분이 있음 알려주세요. 확인 후 반영하도록 하겠습니다.

1 Thread에 대해서

// ... 
pid = fork(); 
if (pid > 0) 
{ 
    // 실제는 이 부분의 코드만 병렬로 실행되면 된다. 
    // fork()는 다른 모든영역의 코드가 복사되어 버린다. 
} 
 

1.1 Thread vs Process

• 프로세스는 독립적이다. 쓰레드는 프로세스의 서브셋이다.
  
• 프로세스는 각각 독립적인 자원을 가진다. 쓰레드는 stat, memory 기타 다른 자원들을 공유한다.
  
• 프로세스는 자신만의 주소영역을 가진다. 쓰레드는 주소영역을 공유한다.
  
• 프로세스는 IPC를 이용해서만 통신이 가능하다.
  
• 일반적으로 쓰레드의 문맥교환(context switching)는 프로세스의 문맥교환보다 빠르다.
  
  

1.2 Multi Thread 프로그램의 단점

• 하나의 쓰레드에서 발생된 문제가 전체 프로세스에 영향을 미친다.
  
  멀티 프로세스의 경우에는 프로세스하나가 문제가 생기더라도 단일 프로세스로 문제가 제한된다. 그러나 멀티쓰레드 프로그램의 경우 하나의 쓰레드에 생긴 문제가 다른 쓰레드에까지 영향을 줄 수 있다. 예를 들어 쓰레드 하나가 다른 프로세스의 메모리 영역을 침범할 경우 프로세스 자체가 죽어버림으로써, 프로세스에 생성된 다른 모든 쓰레드도 프로세스와 함께 죽어버리게 된다. - 이 문제는 해결 가능하지만 여기에서는 다루지 않도록 하겠다. 시그널을 잘 활용하면 된다. 관심있으면 한번 고민해 보기 바란다. -
  
• 디버깅이 어렵다. 문맥이 서로 교환되므로 추적하기가 까다롭다.
  
  

1.3 PThread

• 쓰레드 생성과 종료 관련 함수들
  
• 쓰레드 동기화 관련 함수들
  
  쓰레드는 많은 데이터를 공유한다. 그러므로 데이터에 대한 동기화 문제를 해결해야할 필요가 있다.
  
• 쓰레드 시그널 제어 함수들
  
  signal은 프로세스단위로 작동한다. 그러나 쓰레드 프로그램의 경우, 각 쓰레드 마다 다른 시그널 정책이 필요하므로, 쓰레드 전용의 시그널 제어 함수가 필요하다.
  
  

1.4 Multi Thread 프로그램

1.5 Process, Kernel Thread, User Thread

• 비선점형 : 특정 프로세스가 CPU를 독점하는 것이 가능하다.
  
• 선점형 : 특정 프로세스가 CPU를 독점하는게 불가능하다.
  

1.6 쓰레드의 생성과 종료

1.6.1 pthread_create : 쓰레드 생성

#include <pthread.h> 
 
int  pthread_create(pthread_t  *  thread, pthread_attr_t *attr,  
     void * (*start_routine)(void *), void * arg); 
 

1. thread : 쓰레드가 성공적으로 생성되었을 때, 넘겨주는 쓰레드 식별 번호.
   
2. attr : 쓰레드의 특성을 설정하기 위해서 사용한다. NULL일 경우 기본 특성
   
3. start_routine : 쓰레드가 수행할 함수로 함수포인터를 넘겨준다.
   
4. arg : 쓰레드 함수 start_routine를 실행시킬 때, 넘겨줄 인자
   

1.6.2 pthread_join : 쓰레드 정리

#include <pthread.h> 
 
int pthread_join(pthread_t th, void **thread_return); 
 

1. th : pthread_create에 의해서 생성된, 식별번호 th를 가진 쓰레드를 기다리겠다는 얘기다.
   
2. thread_return : 식별번호 th인 쓰레드의 종료시 리턴값이다.
   
   

1.6.3 쓰레드 생성 예제

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 
 
// 쓰레드 함수 
void *t_function(void *data) 
{ 
    int id; 
    int i = 0; 
    id = *((int *)data); 
 
    while(1) 
    { 
        printf("%d : %d\n", id, i); 
        i++; 
        sleep(1); 
    } 
} 
 
int main() 
{ 
    pthread_t p_thread[2]; 
    int thr_id; 
    int status; 
    int a = 1; 
    int b = 2; 
 
    // 쓰레드 생성 아규먼트로 1 을 넘긴다.   
    thr_id = pthread_create(&p_thread[0], NULL, t_function, (void *)&a); 
    if (thr_id < 0) 
    { 
        perror("thread create error : "); 
        exit(0); 
    } 
 
    // 쓰레드 생성 아규먼트로 2 를 넘긴다.  
    thr_id = pthread_create(&p_thread[1], NULL, t_function, (void *)&b); 
    if (thr_id < 0) 
    { 
        perror("thread create error : "); 
        exit(0); 
    } 
 
    // 쓰레드 종료를 기다린다.  
    pthread_join(p_thread[0], (void **)&status); 
    pthread_join(p_thread[1], (void **)&status); 
 
    return 0; 
} 
 

1.6.4 자식쓰레드를 부모쓰레드로 부터 분리하기

#include <pthread.h> 
#include <stdio.h> 
#include <unistd.h> 
#include <stdlib.h> 
 
// 쓰레드 함수 
// 1초를 기다린후 아규먼트^2 을 리턴한다. 
void *t_function(void *data) 
{ 
    char a[100000]; 
    int num = *((int *)data); 
    printf("Thread Start\n"); 
    sleep(5); 
    printf("Thread end\n"); 
} 
 
int main() 
{ 
    pthread_t p_thread; 
    int thr_id; 
    int status; 
    int a = 100; 
 
    printf("Before Thread\n");  
    thr_id = pthread_create(&p_thread, NULL, t_function, (void *)&a); 
    if (thr_id < 0) 
    { 
        perror("thread create error : "); 
        exit(0); 
    } 
 
    // 식별번호 p_thread 를 가지는 쓰레드를 detach  
    // 시켜준다. 
    pthread_detach(p_thread); 
    pause(); 
    return 0; 
} 
 

1.7 쓰레드 동기화

1. A와 B 두개의 프로세스가 있다. 이 프로세스는 int count=1 이라는 자원을 공유한다.
   
2. A가 count를 읽어들이고 1을 더한다.
   
3. B가 count를 읽어들인다. 아직 A가 count에 쓰지 않았기 때문에, B도 1을 읽어들인다.
   
4. A가 count에 2를 쓴다.
   
5. B도 count에 2를 쓴다.
   
6. count에는 2가 저장되었다.
   

1.8 접근제어

1.8.1 mutex 잠금

1.8.2 mutex의 사용

• mutex 잠금객체을 만드는 함수
  
• mutex 잠금을 얻는 함수
  
• mutex 잠금을 되돌려주는 함수
  
• mutex 잠금객체를 제거하는 함수
  
  

1.8.3 pthread_mutex_init

pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr *attr); 
 

1. mutex : mutex 잠금객체
   
2. mutex_attr : mutex는 fast, 'recursive, error checking의 3종류가 있다. 이 값을 이용해서 mutex 타입을 결정할 수 있다. NULL 일경우 기본값이 fast가 설정된다.
   
   • fast : 하나의 쓰레드가 하나의 잠금만을 얻을 수 있는 일반적인 형태
     
   • recursive : 잠금을 얻은 쓰레드가 다시 잠금을 얻을 수 있다. 이 경우 잠금에 대한 카운드가 증가하게 된다.
     

• fast : PTHREAD_MUTEX_INITIALIZER
  
• recursive : PTHREAD_RECURSIVE_MUTEX_INITIALIZER
  
• error checking : PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
  
  

1.8.4 pthread_mutex_lock

int pthread_mutex_lock(pthread_mutex_t *mutex); 
 

int pthread_mutex_trylock(pthread_mutex_t *mutex); 
 

1.8.5 pthread_mutex_unlock

int pthread_mutex_unlock(pthread_mutex_t *mutex); 
 

1.8.6 mutex 잠금 예제

int a = 1;  
Thread A 에서 a를 읽어들인다.  
Thread B 에서 a를 읽어들인다.  
Thread A 에서 a = a+1를 한다.  
{  
    a = a+1;  
    결과는 2;  
}  
Thread B 에서 a++를 한다.  
{  
   a = a + 1; // 읽어들인 값이 1이기 때문에  
   역시 결과는 2가 된다.  
}  
 

• Atomicity - mutex 잠금은 최소단위 연적 - atomic operation - 을 보장한다. atomic operation에 대해서 간단히 설명하고 넘어간다. 자세한 내용은 Atomic Operation을 참고하기 바란다.
  
  1. aotomic operation은 일련의 연산 즉 mutex 잠금 연산이 끝날때 까지 다른 프로세스가 그 연산의 변화를 알 수 없는 상태가 되는 연산을 의미한다. (일반적으로 연산은 이전의 연산의 결과를 관찰한 후에서야 이루어질 수 있게다)
     
  2. 전체연산중 하나라도 실패할 경우 모든 연산이 실패하며 시스템은 전체 연산이 시작하기 전의 상태로 복구된다.
     
• Singularity : 한 쓰레드가 뮤택스 잠금을 얻었다면, 이 쓰레드가 뮤택스 잠금을 내어놓기 전까지는 다른 쓰레드가 뮤택스 잠금을 얻을 수 없도록 한다.
  
• None Busy Wait : 이것은 성능과 관련된 것이다. 바쁜대기상태에 놓이지 않는다는 뜻이다. 뮤택스 잠금을 얻을 수 있는지를 확인하기 위한 연산이 필요하지 않는 다는 의미로 받아들이면 될 것이다.
  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <stdio.h>  
#include <unistd.h>  
#include <pthread.h>  
 
int ncount;    // 쓰레드간 공유되는 자원 
pthread_mutex_t  mutex = PTHREAD_MUTEX_INITIALIZER; // 쓰레드 초기화 
 
// 쓰레드 함 수 1 
void* do_loop(void *data) 
{ 
    int i; 
 
    pthread_mutex_lock(&mutex); // 잠금을 생성한다. 
    for (i = 0; i < 10; i++) 
    { 
        printf("loop1 : %d", ncount); 
        ncount ++; 
        sleep(1); 
    } 
    pthread_mutex_unlock(&mutex); // 잠금을 해제한다. 
} 
 
// 쓰레드 함수 2 
void* do_loop2(void *data) 
{ 
    int i; 
 
    // 잠금을 얻으려고 하지만 do_loop 에서 이미 잠금을  
    // 얻었음으로 잠금이 해제될때까지 기다린다.   
    pthread_mutex_lock(&mutex); // 잠금을 생성한다. 
    for (i = 0; i < 10; i++) 
    { 
        printf("loop2 : %d", ncount); 
        ncount ++; 
        sleep(1); 
    } 
    pthread_mutex_unlock(&mutex); // 잠금을 해제한다. 
}     
 
int main() 
{ 
    int thr_id; 
    pthread_t p_thread[2]; 
    int status; 
    int a = 1; 
 
    ncount = 0; 
    thr_id = pthread_create(&p_thread[0], NULL, do_loop, (void *)&a); 
    sleep(1); 
    thr_id = pthread_create(&p_thread[1], NULL, do_loop2, (void *)&a); 
 
    pthread_join(p_thread[0], (void *) &status); 
    pthread_join(p_thread[1], (void *) &status); 
 
    status = pthread_mutex_destroy(&mutex); 
    printf("code  =  %d", status); 
    printf("programing is end"); 
    return 0; 
} 
 

1.9 앞으로 할 것

Command Pattern

패턴과 패턴에 대한 (UML을 포함한)설명글을 보면 역시 사용하는 것보다 설명하는게 더 어렵군이라는 느낌이다. 내 생각을 잘 이해하기 쉽게 잘 전달해보자라는 마음가짐으로 가능한 평이하게 글을 만들어 봐야겠다.

Command Pattern은 행동자체를 객체로 본다. 행동을 객체로 봄으로써 좀더 쉽게 명령을 내리기 전의 상태로 복귀할 수 있다. 문제가 생길때 마다 그때 그때 쪽지로 일거리를 만들어서 주는 경우를 생각해 보자. 나중에 그 결과를 정리하는 것도 매우 복잡한 일이 될 확률이 높을 것이다. 이렇게 하지 않고 문제자체를 객체로 만들어서, 그러니까 문제를 분류하고 묶어서 서류철을 만들어서 넘기고 결과를 포함한 서류철을 다시 받게 된다면 문제에 대한 처리가 훨씬 간결해 질 것이다. 일반적인 업무처리에서도 흔히볼 수 있는 방식이기도 하다. Command Pattern이란 즉 수행해야할 문제 혹은 명령을 객체로 처리하는 방식이라고 정의내릴 수 있을 것이다.

이러한 특징은 다음과 같은 응용에 유용하다.

1. Multi-level undo
   
   유저의 명령을 객체로 만든다. 만들어진 명령객체은 stack에 유지시키면,가장 최근에 실행된 명령이 가장 위에 놓이게 될 것이다. undo를 원한다면 undo() 메서드를 실행시켜서 pop을 하면 된다.
   
2. Progress bar
   
   프로그램에게 주어진일의 명령의 연속으로 이루어진다고 가정한다. 이때 각각의 명령객체는 getEstimatedDuration메서드를 가진다. 프로그램은 이 메서드를 이용해서 명령이 어느정도 수행되었는지를 쉽게 판단할 수 있다.
   
3. thread pool
   
4. parallel processing
   
5. networking
   
   

Command

이 패턴에서 가장 중요한 클래스는 명령을 수행하는데 필요한 인터페이스를 가지고 있는 Command객체다. 일상업무에서의 작업요청서라고 볼 수 있을 것이다. 우리가 이 패턴을 사용하는 이유는 명서세에 적혀있는 명령을 실행하는 것이므로 명령을 수행하기 위한 execute메서드를 포함한다.

ConcreteCommand

Receiver객체가 어떤 Action을 취할지를 정의한다.

Receiver

주어진 요청에 대해서 어떤일을 수행해야 하는지를 알고 있는 객체.

Invoker

명령의 수행을 요청한다.

Client

ConcreteCommand 객체를 생성한다.

예제

C++

간단한 요리 프로그램이다. 재료를 준비를 위한 준비명령객체, 준비된 재료를 가지고 프라이팬에 볶는등의 작업을 하는 행동명령객체가 준비된다. 요리는 사람이 하는 거라서 때때로 실수가 있을 수 있기 때문에 Undo기능을 가진다. Undo 기능은 명령객체를 stack에 쌓아두고 pop하는 것으로 구현할 수 있다. 빠른 구현을 위해서 STL의 vector를 사용했다.

#include <iostream> 
#include <vector> 
#include <string> 
 
using namespace std; 
 
// 가상메서드를 포함한 인터페이스 슈퍼 클래스  
class Command{ 
  public: 
   virtual void execute(void) =0; 
   virtual ~Command(void){}; 
}; 
  
class Ingredient : public Command { 
  public: 
   Ingredient(string amount, string ingredient){ 
      _ingredient = ingredient; 
      _amount = amount; 
   } 
   void execute(void){ 
      cout << " *Add " << _amount << " of " << _ingredient << endl; 
   } 
  private: 
   string _ingredient; 
   string _amount; 
}; 
  
class Step : public Command { 
  public: 
   Step(string action, string time){ 
      _action= action; 
      _time= time; 
   } 
   void execute(void){ 
      cout << " *" << _action << " for " << _time << endl; 
   } 
  private: 
   string _time; 
   string _action; 
}; 
 
// command를 저장하고 꺼내기 위한 stack 클래스  
class CmdStack{ 
  public: 
   void add(Command *c) { 
      commands.push_back(c); 
   } 
   void createRecipe(void){ 
      for(vector<Command*>::size_type x=0;x<commands.size();x++){ 
         commands[x]->execute(); 
      } 
   } 
   void undo(void){ 
      if(commands.size() > 0) { 
         commands.pop_back(); 
      } 
      else { 
         cout << "Can't undo" << endl; 
      } 
   } 
  private: 
   vector<Command*> commands; 
}; 
  
int main(void) { 
   CmdStack list; 
  
   //Create ingredients 
   Ingredient first("두스푼", "식용유"); 
   Ingredient second("세컵", "쌀"); 
   Ingredient third("한스푼","케찹"); 
   Ingredient fourth("네홉", "콩"); 
   Ingredient fifth("한스푼", "간장"); 
  
   //Create Step 
   Step step("후라이팬에 볶기","3-4분 정도"); 
  
   //Create Recipe 
   cout << "볶음밥을 만들어봅시다." << endl; 
   list.add(&first); 
   list.add(&second); 
   list.add(&step); 
   list.add(&third);  
   list.undo(); 
   list.add(&fourth); 
   list.add(&fifth); 
   list.createRecipe(); 
   cout << "요리시작!" << endl; 
   return 0; 
} 
 

C

음.. 그닥 객체지향적이지 않다고 생각되는 C를 이용해서도 구현해 봐야 겠다. 다음과 같은 요소들이 필요하지 않을까 싶다.구조체에 함수포인터 다발을 두는 것으로 클래스 비슷하게 만들어낼 수 있긴 하겠다.

PHP

애초에 전혀 객체지향적이지 않게 만들어졌던 php는 php4가 되어서야 class 키워드를 제공하기 시작했고 php5에 이르러서 그럭저럭 객체지향적이다라는 얘기를 듣게 되었다. 이제는 객제지향 패턴을 사용해서 만들어진 PHP 프로그램도 어렵지 않게 찾아볼 수 있다.

1 이유

다양한 애플리케이션에 사용가능한 로그분석 프로그램을 만들려고 한다. 이러한 프로그램의 경우 어떤 애플리케이션에서 사용할지 알 수 없기 때문에, 원본소스에는 수정할 필요 없이 로그분석 알고리즘만 적재가능하도록 만들 필요가 있다.

가장좋은 방법은 main 코드와 알고리즘을 분리시키는 것으로, 이것은 라이브러리의 동적적재를 이용해서 달성가능 하다. 동적적재는 라이브러리문서에 언급되어 있다.

즉 알고리즘을 플러그인 형태로 적재하는 기술인데, 여기에 더해서 C++의 클래스를 동적으로 적재시킬 수 있기를 원했다. 그렇다면, 클래스의 추상화를 이용해서, 좀더 일관된 개발자 인터페이스를 제공할 수 있을 것이기 때문이다.

그러므로 다음의 두가지를 달성하는게 주요 목표가 될 것이다.

1. 로그분석 알고리즘을 플러그인 형태로 적재할 수 있도록 한다.
   
2. 클래스를 적재함으로써, 일관된 개발자 인터페이스를 제공한다.
   
   

2 C++로 작성된 라이브러리사용의 문제

C++에서 클래스의 동적적재 가능성에 대해 생각해 본다.

C에서의 라이브러리의 동적적재는 명료하다. 이에 대한 내용은 라이브러리만들기 문서를 참고한다.

C++에서는 name mangling 때문에 dlopen()을 이용해서 라이브러리를 적재하는데, 어려움이 있다. 애시당초 dlopen()이 C++을 염두에 두지 않고 만들었다는 것도 문제일 것이다.

C와 C++은 함수를 가리키기위한 symbol 테이블을 가지고 있다. 어떤 함수를 호출하면 symbol 테이블을 뒤져서, 이진파일 내에서 함수의 원본의 위치를 알아내어서 읽어들이고 실행하는 것으로 묘사할 수 있다.

C는 symbol이 하나의 함수와 대응한다. 그렇지만 C++은 overloading으로 인하여서, 함수이름과 심볼이 일치하지 않는 경우가 발생한다. 이름은 같지만 인자가 다른 함수가 대표적인 경우다. 그러므로, C++로 공유라이브러리를 만들고자 할경우, 이 함수는 반드시 유일하다는 것을 컴파일러에게 알려줄 필요가 있다.

3 extern "C" 를 이용한 해결

오버로딩으로 인해서 발생하는 문제는 extern "C"를 이용하면 해결할 수 있다. extern "C" 는 해당 함수가 심볼이름과 일치될 것이라는 것을 알려준다. 이를테면 C 함수와 마찬가지로 사용하겠다는 의미다. 대신 C++의 기능인 overload등은 사용할 수 없게 된다.

예컨데 hello란 함수가 있다면, 다음과 같이 extern "C"를 이용해서 정의할 수 있다.

#include <iostream> 
 
using namespace std; 
extern "C" void hello() 
{ 
    cout << "hello" << "\n";     
} 
 

4 class의 동적적재

exern "C"를 이용해서, 오버로딩이 필요없는 함수를 적재시키는 법에 대해서 알아봤다. 그렇다면, class는 어떨까.

안타깝게도 class는 dlopen()을 이용해서 호출할 수가 없다. 애초에 dlopen이 class를 염두에 두고 만들어진게 아니기 때문이다. 가장 일반적으로 사용할 수 있는 방법은 class에 대한 포인터를 넘겨주는 factory 함수를 만들고, 이 포인터를 이용해서 메서드를 호출하는 방법일 것이다.

다음은 factory 함수를 이용해서 클래스를 호출하는 예제 프로그램이다. 프로그램이름은 main.cc로 하겠다.

#include <dlfcn.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
#include "mymodule1.h" 
 
int main(int argc, char **argv) 
{ 
  void *handle; 
 
  char *error; 
  Test *LTest; 
 
  handle = dlopen("libmymodule.so", RTLD_LAZY); 
  if (!handle) 
  { 
    perror("Open Library\n"); 
    exit(0); 
  } 
 
  // Func_Init 
  init_t* init_myFunc = (init_t *)dlsym(handle, "Func_Init"); 
  if ((error = dlerror()) != NULL) 
  { 
    printf("ERROR : %s\n",error); 
    exit(0); 
  } 
  LTest = init_myFunc(); 
  LTest->Count(); 
  LTest->Count(); 
  LTest->Print(); 
 
  // Func_destory 
  destroy_t *destroy_myFunc = (destroy_t *)dlsym(handle, "Func_destory"); 
  destroy_myFunc(LTest); 
} 
 

mymodule1.h로 class Test가 선언되어 있다.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#ifndef _MYMODULE_H_ #define _MYMODULE_H_ #include <stdio.h> #include <string> using namespace std; class Test { private: int count; public: Test(); ~Test() { printf("Destory\n"); } void Count(); void Print(); }; extern "C" class Test* Func_Init(); extern "C" void Func_destory(class Test *aTest); typedef void destroy_t(Test*); typedef Test* init_t(); #endif

Funic_init와 Func_destory라는 factory 함수가 선언되어있다.

다음은 Test 클래스와 factory 함수가 정의되어 있는 코드로 파일명은 mymodule1.cc다.

#include "mymodule1.h" 
 
Test::Test() 
{ 
    printf("Init\n"); 
    count=0; 
} 
 
void Test::Count() 
{ 
    count++; 
} 
 
void Test::Print() 
{ 
    printf("Count is %d\n", count); 
} 
 
class Test* Func_Init() 
{ 
    Test *myTest; 
    myTest = new Test; 
    return myTest; 
} 
 
void Func_destory(class Test *aTest) 
{ 
    delete aTest; 
} 
 
void Func_Test(class Test *aTest) 
{ 
    aTest->Count(); 
    aTest->Print(); 
} 
 

다음은 컴파일 방법이다. 먼저 mymodule1.cc를 공유라이브러리형태로 컴파일 한다.

# g++ -fPIC -c mymodule1.cc 
# g++ -shared -W1,-soname,libmymodule.so.1 -o libmymodule.so.1.0.1 mymodule1.o 
 

main.cc를 컴파일 한다.

g++ -o main main.c -ldl -lmymodule 
 

일반적인 동적적재의 경우 함수원형이 필요 없지만 class의 경우에는 메서드를 호출해야 하기 때문에 -l옵션을 이용해서 메서드에 대한 정의가 있는 라이브러리 명시적으로 지시해줘야 한다.

만들어진 프로그램을 실행시켜 보자.

$ ./main 
Init 
Count is 2 
Destory 
 

제대로 실행됨을 알 수 있다.

5 다형성의 구현

factory 함수를 이용해서 클래스를 로딩할 수 있는 방법을 터득했으니, 이제 로그분석 프로그램 제작에 대한 계획을 세워보기로 하자.

이 로그분석 프로그램은 다음과 같은 사항들을 만족시켜야 한다.

1. 다양한 로그에 대응할 수 있도록 플러그인형식으로 적재할 수 있어야 한다.
   
2. 프로그래머에게 공통의 인터페이스를 제공할 수 있어야 한다.
   

1번 요구사항은 라이브러리의 동적적재를 이용해서 해결할 수 있다. 즉 설정파일을 만든다음에, 해당 로그파일에 대응되어서 적재할 라이브러리를 명시해주면 된다. 이것에 대한 간단한 예는 라이브러리의 사용에 언급되어 있으니, 응용하는데 문제없을 것이다.

2번 요구사항은 클래스를 적재시키고, 클래스의 메서드를 가상함수화 하는 것으로 달성할 수 있을 것이다. 일종의 Interface 클래스를 만들고, 개발자는 Interface의 메서드를 구현하는 방식으로 필요한 모듈을 개발하는 것이다.

6 예전 방식 구현

예전에도 로그분석 비스무레한 프로그램을 만들었던 적이 있다. 보안로그분석프로그램이였는데, 보안장비로 부터 syslog, snmp 혹은 전용 socket으로 부터 보안로그를 받아서 분석하고, 이벤트를 생성하는 프로그램이였다. 기본개념은 DOS 공격검사 프로그램의 제작에 소개된 바가 있다.

기본 시스템/네트워크 구성은 다음과 같다.

보안장비는 다양한 종류의 보안소프트웨어가 설치되어 있으며, 로그 또한 전혀표준화 되어 있지 않으며, 나름대로의 정책을 가지고 만들어진다. 만약 새로운 장비가 추가된다면, 분석소프트웨어는 해당 장비의 보안로그를 분석할 수 있는 기능이 추가되어야 한다.

이 프로그램은 다음의 조건을 만족할 수 있어야 했다.

1. 새로운 보안장비 혹은 새로운 보안 제품이 추가되면, 다음과 같은 이유로 새로운 분석모듈을 개발해야 한다.
   
   • 보안로그가 표준화 되어 있지 않았기 때문
     
   • plain text, binary 데이터 혹은 DB로 log를 저장하는 등 방식의 차이
     
   • snmp, syslog, 전용 socket 등 다양한 통신 방법
     
2. 가능한 main 코드는 수정되지 않아야 한다.
   
3. 모듈의 개발은 일관성이 담보될 수 있어야 한다.
   

위의 요건들을 만족시키기 위해서 다음의 방법을 사용했다. 일종의 전술패턴의 응용이라고 볼 수 있을 것이다.

1. 각 제품에 대응되는 라이브러리를 생성한다. 10개의 제품의 로그를 분석해야 한다면, 10개의 라이브러리가 만들어질 것이다.
   
2. {해당장비 => 해당장비의 로그를 분석할 수 있는 알고리즘이 포함된 라이브러리}를 선택하도록 전술을 구사한다.
   

이 방식은 함수포인터를 이용한 프로토콜 처리에 비슷하게 구현되어 있으니 참고하기 바란다.

이 방식은 만족시켜야할 조건중 1번과 2번은 어느정도 만족시킬 수 있지만, 3번을 만족시키지는 못했다. 코드가 객체지향적이지 않았기 때문에, 즉 C로 개발되었기 때문이다. 물론 좀더 노력과 시간을 들였다면, 3번을 만족시킬 수 있는 프로그램의 제작이 가능했겠지만, 그때는 그럴만한 실력을 갖추지 못했다.

7 방법의 개선

그래서 class의 가상함수를 이용해서 개발자 인터페이스를 만들고, 이 인터페이스를 상속받아서 실제 구현을 하도록 하는 방법을 생각했다. 여기에서는 대략적인 개념만 소개하는 정도로 하겠다.

다음과 같이 순수가상함수를 포함하는 Interface 클래스를 만들도록 한다. interface.h로 하겠다.

#ifndef _INTERFACE_H_ 
#define _INTERFACE_H_ 
 
class Log 
{ 
  private: 
    int data; 
  public: 
    virtual int Create()=0; 
    virtual int Anly()=0; 
    virtual int Read()=0; 
    virtual int Destroy()=0; 
    virtual ~LogAnly() 
    { 
    } 
}; 
 
#endif 
 

• 이제 개발자는 모듈의 작성시 위의 Log클래스를 상속받고, 각 가상함수를 실구현하면 된다.
  
  • Create : 객체를 생성한다.
    
  • Anly : 실제 분석을 한다.
    
  • Read : 분석된 데이터를 읽어들인다.
    
  • Destroy : 객체를 파괴한다.
    

다음은 실구현을 포함한 코드다.

#include <interface.h> 
#include <iostream> 
 
class TestLogAnly : public Log 
{ 
  private: 
  struct _CountData 
  { 
    int count1; 
    int count2; 
  }; 
  _CountData CData; 
  Config *Cfg; 
  public: 
    TestLogAnly(); 
    int Create(char *); 
    int Anly(); 
    int Read(); 
    int Destroy(); 
    ~TestLogAnly(); 
}; 
 
using namespace std; 
int TestLogAnly::Create() 
{ 
  cout << "Create " << endl; 
  return 1; 
} 
 
int TestLogAnly::Destroy() 
{ 
  cout << "Module Anly Destroy" << endl; 
  return 1; 
} 
 
int TestLogAnly::Anly() 
{ 
  CData.count1 = 100; 
  CData.count2 = 200; 
  cout << "Log Anly" << endl; 
  return 1; 
} 
int TestLogAnly::Read() 
{ 
  cout << "ReadData count 1 : "<< CData.count1 << endl; 
  cout << "ReadData count 2 : "<< CData.count2 << endl; 
} 
 
TestLogAnly::~TestLogAnly() 
{ 
  cout << "Module Destroy" << endl; 
} 
 
TestLogAnly::TestLogAnly() 
{ 
  memset((void *)&CData, 0x00, sizeof(CData)); 
} 
 
// factory 함수의 선언 
extern "C" TestLogAnly *Obj_Create(); 
extern "C" void Obj_Destroy(TestLogAnly *); 
 
TestLogAnly *Obj_Create() 
{ 
        TestLogAnly *rtv; 
        rtv = new TestLogAnly(); 
        return rtv; 
} 
 
void Obj_Destroy(TestLogAnly *aLog) 
{ 
        delete aLog; 
} 
 

이것으로 동적적재에도 클래스의 가상화, 추상화, 은닉을 적용할 수 있게 되었다.

1 프로세스에 대해서

 
   Hard Disk      |       | Memory   
 +-------------+  |       | 
 | Program     |  |       | ... 
 |-------------+  | COPY  | +------------+ 
 | Instruction |--|------>| | Process    | 
 | Data        |  |       | | Exec Image | 
 +-------------+  |       | +------------+ 
                  |       | 
 

1. 서로 완전히 독립적인 프로그램의 실행 가능
   
2. 여러개의 이미지를 만들 수 있으므로, 멀티프로세스/멀티쓰레딩 지원
   
   

2 프로세스의 상태

1. running 상태 : 실행가능한 상태를 말한다.
   
2. waiting 상태 : 어떤 조건을 기다리는 상태.
   
3. stopped 상태 : 실행이 중단된 상태.
   
4. zombie 상태 : 실행이 끝나고, 메모리 상에서 프로세스의 이미지가 제거 되었으나 운영체제의 커널은 여전히 프로세스의 정보를 가지고 있는 상태. zombie에 대해서는 뒤에서 자세히 다루도록 하겠다.
   
   

3 프로세스의 모드

1. 유저모드 : 사용자 연산을 위한 모드로 사칙연산과 같은 연산작업으로 사용자 권한으로 각정 명령이 실행된다.
   
2. 커널모드 : 주로 컴퓨터의 자원인 메모리, 하드디스크등의 장치에 접근하기 위한 모드로, 커널권한으로 실행된다.
   
   

4 프로세스의 실행

#include <unistd.h> 
int execl(const char *path, const char *arg, ...); 
 

• path : 실행되는 프로그램의 완전한 경로다.
  
• arg : 이것은 프로그램이 실행될때, 넘겨질 실행인자들로, 여러개가 정의될 수 있다. 더이상 넘겨질 실행인자가 없다는 것을 분명하 하기 위해서, 마지막에 NULL을 입력해줘야 한다. 간단히 ls(1)를 실행시키는 프로그램을 만들어 보자.
  

#include <unistd.h> 
 
int main(int argc, char **argv) 
{ 
    execl("/bin/ls", "ls", "-al", NULL); 
} 
 

1
2
3
4
5
6
7
8
9
10

#include <unistd.h> 
#include <stdio.h> 
 
int main(int argc, char **argv) 
{ 
  printf("Start\n"); 
  execl("/bin/ls", "ls", "-al", NULL); 
  printf("End\n");    // 실행되지 않는다. 
} 
 

$ ./execTest 
Start 
drwxr-xr-x  2 yundream yundream 4096 2008-02-29 00:08 . 
drwxr-xr-x 60 yundream yundream 4096 2008-02-29 00:08 .. 
-rwxr-xr-x  1 yundream yundream 6585 2008-02-29 00:08 execTest 
-rw-r-----  2 yundream yundream   81 2007-12-17 23:59 hello.txt 
-rw-r--r--  1 yundream yundream   12 2007-11-26 23:58 test.txt 
-rw-r--r--  1 yundream yundream  489 2007-11-26 23:53 write.c 
$ 
 

5 멀티 - 다중 - 프로세스

  +---------+        +--------------+ 
  | Process |----+---| Copy Process | 
  +---------+    |   +--------------+ 
                 |   +--------------+ 
                 +---| Copy Process | 
                 |   +--------------+ 
                 |  
                 +--- ... 
 

5.1 fork를 이용한 자식프로세스 생성

#include <unistd.h> 
 
pid_t fork(void); 
 

#include <unistd.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
 
int main() 
{ 
    int pid; 
    int i; 
 
    i = 1000; 
    pid = fork(); 
    if (pid == -1) 
    { 
        perror("fork error "); 
        exit(0); 
    } 
    // 자식프로세스가 실행시키는 코드 
    else if (pid == 0) 
    { 
        printf("자식 : 내 PID는 %d\n", getpid()); 
        while(1) 
        { 
            printf("-->%d\n", i); 
            i++; 
            sleep(1); 
        } 
    } 
    // 부모프로세스가 실행시키는 코드 
    else 
    { 
        printf("부모 : 내가 낳은 자식의 PID는 %d\n", pid); 
        while(1) 
        { 
           printf("==>%d\n", i); 
           i += 4; 
           sleep(1); 
        } 
    } 
} 
 

$ ps -ef | grep forktest 
UID        PID  PPID  C STIME TTY          TIME CMD 
yundream 12119  8557  0 17:33 pts/0    00:00:00 ./forktest 
yundream 12120 12119  0 17:33 pts/0    00:00:00 ./forktest 
 

5.2 fork와 exec를 이용한 새로운 프로세스의 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <sys/wait.h> 
#include <sys/types.h> 
 
#define chop(str) str[strlen(str)-1] = 0x00; 
 
int main(int argc, char **argv) 
{ 
  char buf[256]; 
  printf("My Shell\n"); 
  int pid; 
  while(1) 
  { 
    // 사용자 입력을 기다린다. 
    printf("# "); 
    fgets(buf, 255, stdin); 
    chop(buf); 
 
    // 입력이 quit 라면, 프로그램을 종료한다. 
    if (strncmp(buf, "quit", 4) == 0) 
    { 
      exit(0); 
    } 
 
    // 입력한 명령이 실행가능한 프로그램이라면 
    // fork 한후 execl을 이용해서 실행한다. 
    if (access(buf, X_OK) == 0) 
    { 
      pid = fork(); 
      if (pid < 0) 
      { 
        fprintf(stderr, "Fork Error"); 
      } 
      if (pid == 0) 
      { 
        if(execl(buf, buf, NULL) == -1) 
          fprintf(stderr, "Command Exec Error\n\n"); 
        exit(0); 
      } 
      if (pid > 0) 
      { 
        // 부모 프로세스는 자식프로세스가 종료되길 기다린다. 
        int status; 
        waitpid(pid, &status, WUNTRACED); 
      } 
    } 
    else // 만약 실행가능한 프로그램이 아니라면, 에러메시지를 출력 
    { 
        fprintf(stderr, "Command Not Found\n\n"); 
    } 
  } 
} 
 

MY Shell 
$ myshell 
# /usr/bin/w 
 01:15:32 up  2:58,  4 users,  load average: 0.47, 0.50, 0.62 
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT 
yundream :0       -                00:05   ?xdm?  14:20m  0.05s /bin/bash /usr/ 
yundream pts/1    :0               00:06    9.00s  1.47s  1.24s w3m -F http://w 
yundream pts/3    :0               00:54    0.00s  0.22s  0.00s ./myshell 
yundream pts/4    :0.0             00:53   22:13m  0.40s  0.27s BitchX irc.nuri 
 
# ll 
Command Not Found 
 
# quit 
$ 
 

6 프로세스 관계

6.1 부모프로세스와 자식프로세스 init 프로세스

$ pstree 
init─┬─NetworkManager───{NetworkManager} 
     ├─NetworkManagerD 
     ├─acpid 
     ├─amarok───11*[{amarok}] 
     ├─atd 
     ├─avahi-daemon───avahi-daemon 
     ├─bonobo-activati───{bonobo-activati} 
     ├─console-kit-dae───61*[{console-kit-dae}] 
     ├─cron 
     ├─cupsd 
     ├─2*[dbus-daemon] 
     ├─dbus-launch 
       .... 
 

6.2 프로세스의 identify와 관계에서의 위치

1. name : 프로세스의 이름이다.
   
2. PID : Process ID로 운영체제가 각각의 프로세스에 부여하는 유일한일련 번호다. 프로세스의 이름만으로도 identify를 확보할 수 있을거라고 생각할 수 있지만 이름이 같은 프로세스가 생성될 수 있으므로, name만 가지고는 identify를 확보할 수 없다. 때문에 운영체제에서 일련번호를 부여하게 된다. 이 번호는 중복되지 않는 유일한 번호다. 일종의 주민등록번호 정도로 보면 될 거 같다.
   
   

1. PPID : 부모프로세스의 ID로 어떤 프로세스로 부터 생성이 되었는지를 알려준다.
   
2. PGID : 프로세스는 여러개의 자식프로세스를 만들어낼 수 있다. 그렇다면, 이들 프로세스는 {부모-->{자식,자식,자식}}과 같이 하나의 가계를 만들 수 있을 것이다. 운영체제에서는 이것을 가계라고 하는 대신 group이 라고 한다. PGID는 프로세스가 어느 그룹에 포함되어 있는지에 대한 정보를 알려준다. PGID는 일련번호로 되어 있으며, 보통 부모프로세스의 PID즉 PPID가 PGID가 된다. 즉 프로세스그룹은 부모프로세스의 PID를 공통분모로 해서 하나의 그룹을 만들게 된다.
   
   

$ ps -efjc | grep forktest  
UID        PID  PPID  PGID   SID CLS PRI STIME TTY          TIME CMD 
yundream 12198  8557 12198  8557 TS   24 17:40 pts/0    00:00:00 ./forktest 
yundream 12199 12198 12198  8557 TS   21 17:40 pts/0    00:00:00 ./forktest 
 

$ ps -efjc | grep 8557 
UID        PID  PPID  PGID   SID CLS PRI STIME TTY          TIME CMD 
yundream  8557  8550  8557  8557 TS   24 13:37 pts/0    00:00:00 bash 
 

        fork&exec                    fork 
  bash ---+----------- forktest ---+-------- forktest 
 

6.3 고아 프로세스

#include <unistd.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
 
int main() 
{ 
    int pid; 
    int i; 
 
    i = 1000; 
    pid = fork(); 
    if (pid == -1) 
    { 
        perror("fork error "); 
        exit(0); 
    } 
    // 자식프로세스가 실행시키는 코드 
    else if (pid == 0) 
    { 
        printf("자식 : 내 PID는 %d\n", getpid()); 
        while(1) 
        { 
            printf("-->%d\n", i); 
            i++; 
            sleep(1); 
        } 
    } 
    // 부모프로세스가 실행시키는 코드 
    else 
    { 
        printf("부모 : 내가 낳은 자식의 PID는 %d\n", pid); 
        sleep(1); 
        printf("T.T 나죽네\n"); 
        exit(0); 
    } 
} 
 

$ ./forktest  
부모 : 내가 낳은 자식의 PID는 8207 
자식 : 내 PID는 8207 
-->1000 
T.T 나죽네 
-->1001 
yundream@yundream-desktop:~$ -->1002 
-->1003 
 
yundream@yundream-desktop:~$ -->1004 
-->1005 
-->1006 
-->1007 
-->1008 
 

#ps -efjc | grep forktest 
UID        PID  PPID  PGID   SID CLS PRI STIME TTY          TIME CMD 
yundream  8207     1  8206  8093 TS   24 00:16 pts/5    00:00:00 ./forktest 
 

6.4 Daemon 프로세스

1. 일단 고아 프로세스가 되어야 한다.
   
   데몬 프로세스는 완전히 독립된 프로세스다. 그러므로 고아 프로세스가 되어야 한다. 예컨데, 가족으로 부터 독립해서 사회로 나가야 된다는 얘기가 되겠다.
   
2. 표준입력, 표준출력, 표준에러을 닫는다.
   
   표준입력과 표준출력, 표준에러는 사용자와 프로세스가 상호작용 하기 위한 장치로, 표준입력은 키보드, 표준출력은 모니터로 대응된다. 데몬 프로세스는 뒤에서 독립적으로 돌아가는 프로세스 이므로 사용자와의 상호작용을 해서는 안된다. 그러므로 표준입력과 표준출력을 표준에러를 닫아줄 필요가 있다. 뒤에서 혼자 돌아야 하는 프로그램인데, 모니터에 (forktest2.c 와 같이) 잡다한 메시지를 출력해서는 안될 것이기 때문이다.
   
3. 터미널을 가지지 않는다.
   
   터미널이란 사용자가 컴퓨터에 접속된 상태를 말한다. 이 터미널에 키보드와 모니터와 같은 장치가 연결되어 있고, 이것을 이용해서 사용자의 프로세스가 컴퓨터와 연결이 된다. 데몬 프로세스는 사용자 환경과 독립되어야 하므로 터미널을 끊어줘야 한다.
   
   

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <unistd.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
 
int main() 
{ 
    int pid; 
    int i; 
 
    i = 1000; 
    pid = fork(); 
    if (pid == -1) 
    { 
        perror("fork error "); 
        exit(0); 
    } 
    // 자식프로세스가 실행시키는 코드 
    else if (pid == 0) 
    { 
        printf("자식 : 내 PID는 %d\n", getpid()); 
        close(0); 
        close(1); 
        close(2); 
        setsid(); 
        while(1) 
        { 
            printf("-->%d\n", i); 
            i++; 
            sleep(1); 
        } 
    } 
    // 부모프로세스가 실행시키는 코드 
    else 
    { 
        printf("부모 : 내가 낳은 자식의 PID는 %d\n", pid); 
        sleep(1); 
        printf("T.T 나죽네\n"); 
        exit(0); 
    } 
} 
 

1. 39 에서 부모프로세스를 종료한다.
   
2. 22,23,24 에서 표준입력,표준출력,표준에러를 닫았다.
   
3. setsid()를 이용해서, 사용자환경에서 독립된 자신의 환경을 만든다. 기존의 환경이 리셋되면서 터미널이 사라진다. 또한 새로운 터미널을 지정하지 않았기 때문에, 이 프로세스는 결과적으로 터미널을 가지지 않게 된다.
   
   

$ ps -efjc | grep daemon  
UID        PID  PPID  PGID   SID CLS PRI STIME TTY          TIME CMD 
yundream  8252     1  8252  8252 TS   24 00:43 ?        00:00:00 ./daemon 
 

소개

여기에서는 다중의 머지소트(Merged Sort)에 대해서 생각해 보도록 하겠다. 머지소트를 하기 위해서는 3개의 버퍼가 필요하다는 것을 알고 있을 것이다.

1. A에 자료를 집어 넣고
   
2. B에 자료를 집어 넣은다음
   
3. A와 B를 Merge 해서 결과를 C에 넣는다.
   
4. 새로운 데이터가 있다면 다시 A에 넣고
   
5. A와 C를 Merged 해서 결과를 B에 놓는다.
   
6. 위의 순서를 반복한다.
   
   

이러한 일반적인 merged sort는 그다지 어려울 것이 없다고 생각된다. 그러나 다음과 같은 경우를 생각해볼 수 있다.

3개의 A, B, C 그룹이 있고, C그룹의 데이터들을 머지소트한 결과와 B그룹의 데이터들을 머지소트한 결과를 다시 머지 소트하고, 이 결과를 다시 A그룹의 머지소트한 결과의 머지소트해서 최종 결과를 가져온다.

이러한 요구는 같이 가중치(Level)를 달리하는 서로다른 그룹에 대해서 머지소트하고 이들 그룹을 다시 머지소트해서 Score를 산출해야 하는 검색엔진등에서 발생할 수 있을 것이다.

간단히 생각하자면, 각 그룹을 머지소트하는데 3개의 버퍼가 필요하므로, 3x2 = 6개의 버퍼로 필요한 계산을 할 수 있을 것이다. 그러나 이 경우 대량의 메모리를 낭비할 수 있다는 문제가 발생한다. 머지소트해야할 데이터가 1,000,000의 레코드로 이루어져 있고, 각각의 레코드의 크기가 20byte 정도라면 한번의 머지소트를 위해서 120M의 메모리를 소비해야 한다. 여기에 동시접속까지 제어해야 하는 서비스에 사용될 엔진이라면, 10명이 접속했을 때, 1.2기가의 메모리를 소비하게 된다.

이러한 경우 memory풀을 유지해서, 할당하는 등의 방법을 고려해야 겠으나 우선적으로 사용한 메모리의 양을 줄일 필요가 있다. 이 방법에 대해서 고민해보기로 했다.

버퍼 레퍼런스 관리

이 문제를 해결하기 위해서 가능한 최소의 버퍼를 만들어 레퍼런스를 이용해서 재사용하는 방법을 생각해 보았다. 버퍼풀을 유지하기 위한 방법이라고 볼 수 있을 것이다.

여기에는 4개의 버퍼가 사용된다.

1. Buff Manager가 4개의 버퍼중 3개를 얻어낸 다음 Lv1 Merged Sorter 에게 돌려준다.
   
   1. Lv1 Merged Sorted는 주어진 3개의 버퍼를 이용해서 Merged Sorted를 한다.
      
   2. 마지막으로 결과를 저장한 버퍼의 레퍼런스(주소값)을 저장한다.
      
2. Buffer Manager가 4개의 버퍼중 3개를 얻어낸 다음 Lv2 Merged Sorted 에게 돌려준다.
   
   1. 이때 Lv1 Merged Sorter의 최종결과물이 저장된 버퍼는 사용하면 안된다.
      
   2. 우리는 Lv1 Sorter의 결과물 버퍼의 레퍼런스를 알고 있으므로, 이것을 제외한 3개의 버퍼를 Lv2 Sorter에게 할당할 수 있다.
      
   3. Lv2 Sorter은 주어진 3개의 버퍼를 이용해서 merged Sorted를 수행한다.
      
   4. 최종결과를 저장한 버퍼의 레퍼런스를 저장한다.
      
3. 이제 두개의 버퍼에 Lv1 Sorter 과 Lv2 Sorter의 결과물이 있다. 두개를 merged해서 사용가능한 버퍼에 결과물을 저장한다.
   
   

다음은 구현코드다. 아이디어가 실현되는지를 확인하기 위한 코드로 데이터는 int형으로 대신했으며, 실제 merged sort를 하지 않고, 2개의 int형 버퍼에 있는 값을 더해서 남는 버퍼에 저장하도록 했다. 실제 구현은 int형대신, 클래스나 구조체와 같은 자료구조가 들어가고, 덧셈연산대신에 Merged Sort 연산이 들어갈 것이다. 어쨋든 아이디어를 테스트하는데에는 무리가 없을 것으로 생각된다.

아이디어 구현에 집중하기 위해서 STL을 사용했다.

1. 4개의 int형 버퍼중에 3개의 int형 버퍼를 할당한다.
   
   1. 첫번째 버퍼에 1이 들어간다.
      
   2. 두번째 버퍼에 2가 들어간다.
      
   3. 3번째 버퍼에 1+2=3 이 들어간다.
      
   4. 4번째 버퍼에 3이 들어간다.
      
   5. 5번째 버퍼에 3+3=6 이 들어간다.
      
   6. 즉 101번을 루프를 돌면 5050이라는 값이 나와야 한다.
      
2. 4개의 int형 버퍼중에, 이전 결과값이 저장된 버퍼를 제외한 3개를 할당한다.
   
   1. 1번을 반복한다.
      
3. 2개의 버퍼가 모두 찼다면, 이걸 다시 더해서 남는 버퍼에 넣는다.
   
   

#include <iostream> 
#include <vector> 
#include <stdlib.h> 
#include <unistd.h> 
 
using namespace std; 
 
#define BUFSIZE  4 
 
class Buff 
{ 
    private: 
        int currentIdx; 
        vector<int *> LBuf; 
        int *tmpptr; 
 
    public: 
        Buff() 
        { 
            currentIdx = 0; 
        } 
 
        void Set(int *a) 
        { 
            LBuf.push_back(a); 
        } 
 
        void Clear() 
        { 
            LBuf.clear(); 
        } 
 
        // Merged Sort를 한다.  
        // 여기에서는 + 연산을 한다. 
        void SetUnion(int a) 
        { 
            int current = (currentIdx+1)%3; 
            int prev = (currentIdx)%3; 
            int tmp = (currentIdx+2)%3; 
 
            if (*LBuf[prev] != -1) 
            { 
                currentIdx++; 
            } 
            *LBuf[current] = a; 
            *LBuf[tmp] = a + *LBuf[prev];  
            printf("Debug %d + %d = %d\n", *LBuf[current], *LBuf[prev], *LBuf[tmp]); 
            currentIdx ++; 
 
            tmpptr = LBuf[(currentIdx)%3]; 
        } 
 
        // 결과가 저장된 버퍼의 레퍼런스를 넘겨준다. 
        int *GetSumResult() 
        { 
            return tmpptr;  
        } 
 
        int TmpIdx() 
        { 
            return currentIdx; 
        } 
}; 
 
class BufManager 
{ 
    private: 
        int *a; 
        vector<Buff> NodeBuf; 
        int checkIdx; 
 
    public: 
 
        BufManager() 
        { 
            // 버퍼를 4개 할당한다. 
            a = (int *)malloc(sizeof(int) * BUFSIZE); 
            checkIdx = 3; 
        } 
 
        void Run() 
        { 
            Buff lBuff1, lBuff2; 
 
            // 각각의 Buff1에 3개씩의 버퍼의 레퍼런스를 할당한다. 
            for (int i = 0; i < BUFSIZE; i++) 
            { 
                a[i] = -1; 
                if (&a[i] != &a[checkIdx]) 
                { 
                    lBuff1.Set(&a[i]); 
                } 
            } 
            NodeBuf.push_back(lBuff1); 
 
            for (int i = 0; i < BUFSIZE; i++) 
            { 
                a[i] = -1; 
                if (&a[i] != &a[checkIdx]) 
                { 
                    lBuff1.Set(&a[i]); 
                } 
            } 
            NodeBuf.push_back(lBuff2); 
 
            int idxflag = 0; 
            int idx; 
 
            // 2개의 그룹이 있다고 가정하고 루프를 돌렸다.  
            for (int i = 0; i < 2; i++) 
            { 
                Buff Bf; 
                idxflag = i % 2; 
                printf("Node Number %d\n", idxflag); 
                getchar(); 
 
                // 101번의 merged Sort가 이루어진다고 가정한다. 
                for (int k = i; k < 101+i; k++) 
                { 
                    NodeBuf[idxflag].SetUnion(k); 
                } 
 
                // merged Sort가 끝났다면, 버퍼를 초기화 한다. 
                NodeBuf[idxflag].Clear(); 
                checkIdx = NodeBuf[idxflag].TmpIdx(); 
 
                // 2개의 버퍼에 결과값이 만들어졌다면, 이 두개를 다시 Merged sort한다. 
                // 아래의 코드는 SetUnion 메서드를 사용하도록 바꿀 수 있을 것이다. 
                if (i > 0) 
                { 
                    printf("RESULT : %d : %d\n", *NodeBuf[0].GetSumResult(), *NodeBuf[1].GetSumResult() ); 
                    getchar(); 
                } 
 
                // 다음 Level의 Merged Sort를 위해서 3개의 메모리의 레퍼런스를 할당한다.   
                // 이때 이전에 결과값이 있는 메모리는 사용하지 않도록 한다.  
                for (int k = 0; k < BUFSIZE; k++) 
                { 
                    // 주소값이 같지 않을 경우에만 할당한다. 
                    if (&a[k] != NodeBuf[idxflag].GetSumResult()) 
                    { 
                        a[k] = -1; 
                        printf("SET %d\n", k); 
                        Bf.Set(&a[k]); 
                    } 
                } 
                NodeBuf[idxflag?0:1] = Bf; 
                printf("Current Result : %d\n", *NodeBuf[idxflag].GetSumResult()); 
                getchar(); 
            } 
        } 
}; 
 
int main(int argc, char **argv) 
{ 
    BufManager *MyBuff;  
    MyBuff = new BufManager(); 
    MyBuff->Run(); 
} 
 

약간 수정된 코드

동일하게 SetUnion 메서드를 사용하도록 약간 수정했다.

#include <iostream> 
#include <vector> 
#include <stdlib.h> 
#include <unistd.h> 
 
using namespace std; 
 
#define BUFSIZE  4 
 
class Buff 
{ 
    private: 
        int currentIdx; 
        vector<int *> LBuf; 
        int *tmpptr; 
    public: 
         
        Buff() 
        { 
            currentIdx = 0; 
        } 
 
        void Set(int *a) 
        { 
            LBuf.push_back(a); 
        } 
 
        void Clear() 
        { 
            LBuf.clear(); 
        } 
 
        void SetUnion(int a) 
        { 
            int current = (currentIdx+1)%3; 
            int prev = (currentIdx)%3; 
            int tmp = (currentIdx+2)%3; 
 
            if (*LBuf[prev] != -1) 
            { 
                currentIdx++; 
            } 
            *LBuf[current] = a; 
            *LBuf[tmp] = a + *LBuf[prev];  
            printf("Debug %d + %d = %d\n", *LBuf[current], *LBuf[prev], *LBuf[tmp]); 
            currentIdx ++; 
 
            tmpptr = LBuf[(currentIdx)%3]; 
        } 
 
        int *GetSumResult() 
        { 
            return tmpptr;  
        } 
        int TmpIdx() 
        { 
            return currentIdx; 
        } 
}; 
 
class BufManager 
{ 
    private: 
        int *a; 
        vector<Buff> NodeBuf; 
        int checkIdx; 
 
    public: 
 
        BufManager() 
        { 
            a = (int *)malloc(sizeof(int) * BUFSIZE); 
            checkIdx = 3; 
        } 
 
        void Run() 
        { 
            Buff lBuff1, lBuff2; 
 
            for (int i = 0; i < BUFSIZE; i++) 
            { 
                a[i] = -1; 
                if (&a[i] != &a[checkIdx]) 
                { 
                    lBuff1.Set(&a[i]); 
                } 
            } 
            NodeBuf.push_back(lBuff1); 
 
            for (int i = 0; i < BUFSIZE; i++) 
            { 
                a[i] = -1; 
                if (&a[i] != &a[checkIdx]) 
                { 
                    lBuff1.Set(&a[i]); 
                } 
            } 
            NodeBuf.push_back(lBuff2); 
 
            int idxflag = 0; 
            int idx; 
            for (int i = 0; i < 3; i++) 
            { 
                Buff Bf; 
                idxflag = i % 2; 
                printf("Node Number %d\n", idxflag); 
                getchar(); 
                for (int k = 0; k < 10; k++) 
                { 
                    NodeBuf[idxflag].SetUnion(k); 
                } 
 
                NodeBuf[idxflag].Clear(); 
 
                checkIdx = NodeBuf[idxflag].TmpIdx(); 
                if (i > 0) 
                { 
                    int another = idxflag?0:1;  
 
                    printf("RESULT : %d : %d\n", *NodeBuf[idxflag].GetSumResult(), *NodeBuf[another].GetSumResult() ); 
                    NodeBuf[idxflag].SetUnion(*NodeBuf[another].GetSumResult()); 
                    printf("Current Result : %d\n", *NodeBuf[idxflag].GetSumResult()); 
                    getchar(); 
                } 
 
                for (int k = 0; k < BUFSIZE; k++) 
                { 
                    if (&a[k] != NodeBuf[idxflag].GetSumResult()) 
                    { 
                        a[k] = -1; 
                        Bf.Set(&a[k]); 
                    } 
                } 
                NodeBuf[idxflag?0:1] = Bf; 
 
                //printf("Current Result : %d\n", *NodeBuf[idxflag].GetSumResult()); 
                getchar(); 
            } 
        } 
}; 
 
int main(int argc, char **argv) 
{ 
    BufManager *MyBuff;  
    MyBuff = new BufManager(); 
    MyBuff->Run(); 
} 
 

결론

버퍼풀을 이용한 merged sort는 유연하게 확장가능하다는 장점이 있다. 검색엔진을 예로 들자면, 어절이 분리될 경우, 2개 이상의 트리를 가지게 될건데, 이렇게 다수의 트리를 가지는 데이터들을 merged sort 하길 원한다면, 5개의 버퍼를 가지는 풀을 유지하면 될 것이다.

관련글

• 일반 Merged Sort

1장. fopen(3)

파일로 부터 스트림을 생성한다.

#include <stdio.h>

FILE *fopen(const char *path, const char *mode);
FILE *fdopen(int fildes, const char *mode);
FILE *freopen(const char *path, const char *mode, FILE *stream);
		

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv)
{
    FILE *fp;

    fp = fopen("/home/test/test.txt", "r");
    if (fp == NULL)
    {
        perror("File open error: ");
        exit(0);
    }
    // 표준 I/O 함수를 이용한 여러가지 작업을 한다.  

    fclose(fp);
    return 0;
}
		

1.6. 참고문헌

1. open(2)

2. fopen(3)

3. fileno(3)

4. stdio.h 사용하기

간달프(Gandalf)

순교자

팬보이

빈스 닐(Vince Neil): 미국 밴드 머틀리 크루의 리드싱어

닌자

이론가(The Theoretician)

코드 카우보이(The Code Cowboy)

공수부대요원(The Paratrooper)

보통사람(Mediocre Man)

이반젤리스트(The Evangelist)

1 소개

2 모든건 파일이다

3 파일의 종류

# ls -al 
drwxr-xr-x 12 root root       13820 2007-11-12 22:19 . 
drwxr-xr-x 21 root root        4096 2007-10-31 23:47 .. 
drwxr-xr-x  2 root root         100 2007-11-13 06:45 .initramfs 
-rw-r--r--  1 root root           0 2007-11-13 06:45 .initramfs-tools 
drwxr-xr-x  3 root root          60 2007-11-13 06:45 .static 
drwxr-xr-x  5 root root         120 2007-11-12 22:19 .udev 
lrwxrwxrwx  1 root root          13 2007-11-13 06:45 MAKEDEV -> /sbin/MAKEDEV 
crw-rw----  1 root root     10,  63 2007-11-12 21:46 acpi 
crw-rw----  1 root audio    14,  12 2007-11-12 21:46 adsp 
crw-rw----  1 root audio    14,   4 2007-11-12 21:46 audio 
drwxr-xr-x  3 root root          60 2007-11-13 06:45 bus 
lrwxrwxrwx  1 root root           3 2007-11-13 06:45 cdrom -> hda 
 

4 파일 열기

1. 파일을 연다.
   
2. 열려진 파일에서 데이터를 읽거나, 데이터를 쓴다
   
3. 모든 작업이 끝났다면, 파일을 닫는다.
   
   

1. 실제로 존재하는 파일인지 아닌지 확인
   
2. 존재하지 않을 경우 파일을 새로 생성할 것인지 아닌지를 결정
   
3. 파일을 쓸 수 있는 권한이 있는지 확인
   
   리눅스는 다중 사용자 운영체제로 파일을 비롯한 모든 자원에 대한 접근 권한이 설정되어 있다. 따라서 해당 파일을 사용할 수 있는 권한이 있는지 확인하는 것은 당연한 절차다.
   
   

4.1 open 시스템콜을 이용한 파일 열기

#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
 
int open(const char *pathname, int flags); 
int open(const char *pathname, int flags, mode_t mode) 
 

• O_RDONLY
  
  읽기 전용으로 파일을 연다. 쓸수 없다.
  
• O_WRONLY
  
  쓰기 전용으로 파일을 연다.
  
• O_RDWR
  
  읽기와 쓰기 모두가 가능하도록 파일을 연다.
  
• O_CREAT
  
  파일이 존재하지 않을 경우 파일을 생성한다.
  
• O_EXCL
  
  O_CREAT를 써서 파일을 오픈할 경우, 이미 파일이 존재한다면 error를 리턴하게 한다. 파일을 덮어쓰거나 하는 실수를 방지하기 위한 용도로 사용할 수 있다.
  

• S_IRWXU
  
  00700 모드로 파일 소유자에게 읽기, 쓰기, 쓰기 실행권한을 준다.
  
• S_IRUSR
  
  00400 으로 사용자에게 읽기 권한을 준다.
  
• S_IWUSR
  
  00200 으로 사용자에게 쓰기 권한을 준다.
  
• S_IXUSR
  
  00100 으로 사용자에게 실행 권한을 준다.
  
• S_IRWXG
  
  00070 으로 그룹에게 읽기, 쓰기, 실행 권한을 준다.
  
• S_IRGRP
  
  00040 으로 그룹에게 읽기권한을 준다.
  
• S_IWGRP
  
  00020 으로 그룹에게 쓰기권한을 준다.
  
• S_IXGRP
  
  00010 으로 그룹에게 실행권한을 준다.
  
• S_IRWXO
  
  00007 으로 기타 사용자 에게 읽기, 쓰기, 실행 권한을 준다.
  
• S_IROTH
  
  00004 으로 기타 사용자 에게 읽기 권한을 준다.
  
• S_IWOTH
  
  00002 으로 기타 사용자 에게 쓰기 권한을 준다.
  
• S_IXOTH
  
  00001 으로 기타 사용자 에게 실행 권한을 준다.
  
  

// 파일이름 hello.txt 에 데이터를 (단지)쓰기 위해서 연다. 
// 파일이 없을 경우 생성하며 
// 권한은 640 으로 한다. 
open("hello.txt", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); 
 

#include <stdlib.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
 
int main() 
{ 
  int fd; 
  fd = open("hello.txt", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); 
} 
 

yundream@yundream:~$ ls -al hello.txt 
-rw-r----- 1 yundream yundream 0 2007-11-20 20:23 hello.txt 
 

4.2 file descriptor

  +------+ 
  | FILE |<---- file discriptor = open(2) 
  |      | 
  +------+ 
  open으로 리턴된 int형 정수는 file discriptor 로써, 열린 파일을 가리킨다. 
 

  fd = open("hello.txt", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); 
  if (fd < 0) 
  { 
    perror("file open error:"); 
    return 1; 
  } 
 

5 파일에서 읽기

Fly me to the moon And let me play among the stars 
Let me see what spring is like on Jupiter and Mars 
In other words hold my hand 
In other words darling kiss me 
 

  fd = open("fly.txt", O_WRONLY); 
  if (fd < 0) 
  { 
    ... 
  } 
 

5.1 read 시스템콜

#include <unistd.h> 
 
size_t read(int fd, void *buf, size_t count); 
 

1. fd : open(2)으로 열린 파일을 가리키는 파일지정번호
   
2. buf : 읽어들인 데이터를 저장할 공간
   
3. count : 읽어들일 데이터의 크기로 byte 단위
   
   

int readn = 0; 
int fd; 
char buf[80]; 
fd = open(...); 
 
memset(buf, 0x00, 80); 
while( (readn = read(fd, buf, 79) ) 
{ 
  // 읽어들인 데이터가 있는 buf를 이용해서 필요한 작업을 한다. 
  memset(buf, 0x00, 80); 
} 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdlib.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
 
#define MAXLEN 80 
int main() 
{ 
  int fd; 
  int readn = 0; 
  char buf[MAXLEN]; 
  fd = open("fly.txt", O_RDONLY); 
  if (fd < 0) 
  { 
    perror("file open error:"); 
    return 1; 
  } 
  memset(buf, 0x00, MAXLEN); 
  while( (readn = read(fd, buf, MAXLEN-1 )) > 0) 
  { 
    printf("%s", buf); 
  } 
} 
 

Fly me to the moon And let me play among the stars 
Let me see what spring is like on Jupiter and Mars 
In other words hold my hand 
In other words darling kiss me 
on Jupiter and Mars 
In other words hold my hand 
... 
 

  01 ...  89 80 
 +-------+--+--+--------------------------+ 
 | ..... |  |  | '\0'이 아닌 알수 없는 값 | 
 +-------+--+--+--------------------------+ 
 |<--- buf --->| 
 

5.2 버퍼공간의 크기

6 파일에 쓰기

#include <unistd.h> 
 
ssize_t write(int fd, const void *buf, size_t count); 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <fcntl.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <string.h> 
 
int main() 
{ 
    int fd; 
    int i; 
    int wdata = 0; 
    int wsize = 0; 
    fd = open("data.txt", O_CREAT|O_WRONLY); 
    if (fd < 0) 
    { 
        perror("file open error"); 
        return 1; 
    } 
 
    for (i = 0; i < 100; i++) 
    { 
        wdata = i * 2; 
        wsize = write(fd, (void *)&wdata, sizeof(int)); 
        printf("Write %d (%d byte)\n", i*2); 
    } 
    close(fd); 
} 
 

# gcc -o write write.c 
# ./write 
Write 0 (4 byte) 
Write 2 (4 byte) 
Write 4 (4 byte) 
Write 6 (4 byte) 
Write 8 (4 byte) 
 

7 파일 닫기

#include <unistd.h> 
 
int close(int fd); 
 

8 원시 데이터타입의 데이터와 구조체데이터 읽고 쓰기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <stdlib.h> 
#include <stdio.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
 
#define MAXLEN 80 
int main() 
{ 
  int fd; 
  int readn = 0; 
  int buf; 
  fd = open("data.txt", O_RDONLY); 
  if (fd < 0) 
  { 
    perror("file open error:"); 
    return 1; 
  } 
  while( (readn = read(fd, (void *)&buf, sizeof(buf) )) > 0) 
  { 
    printf("Read Data : %d\n", buf); 
  } 
} 
 

# ./read 
Read Data : 0 
Read Data : 2 
Read Data : 4 
Read Data : 6 
Read Data : 8 
... 
 

8.1 좀더 복잡한 구조체 데이터 읽고 쓰기

이름 
나이 
성별 
취미 
 

struct userInfo 
{ 
  char name[28]; 
  int  age; 
  int  sex; 
  char hobb6[28]; 
}; 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

nclude <stdlib.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <string.h> 
#include <stdio.h> 
 
struct userInfo 
{ 
  char name[28]; 
  int age; 
  int sex; 
  char hobby[28]; 
}; 
 
void makeUserInfo(struct userInfo *uinfo, 
  char *name, // 이름 
  int age,    // 나이 
  int sex,    // 성 (남: 0, 여: 1) 
  char *hobby) // 취미 
{ 
  memset((void *)uinfo, 0x00, sizeof(struct userInfo)); 
  strcpy(uinfo->name, name); 
  uinfo->age = age; 
  uinfo->sex = sex; 
  strcpy(uinfo->hobby, hobby); 
} 
 
int main() 
{ 
  int fd; 
  struct userInfo myAddrBook; 
  fd = open("hello.txt", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); 
  if (fd < 0) 
  { 
    perror("file open error"); 
    return 1; 
  } 
 
  makeUserInfo((void *)&myAddrBook, "yundream", 19, 0, "프로그래밍"); 
  write(fd, (void *)&myAddrBook, sizeof(myAddrBook)); 
 
  makeUserInfo((void *)&myAddrBook, "hello", 22, 1, "게임"); 
  write(fd, (void *)&myAddrBook, sizeof(myAddrBook)); 
 
  makeUserInfo((void *)&myAddrBook, "드라고너", 33, 1, "사냥"); 
  write(fd, (void *)&myAddrBook, sizeof(myAddrBook)); 
 
  close(fd); 
  return 0; 
} 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <stdlib.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <string.h> 
#include <stdio.h> 
 
struct userInfo 
{ 
  char name[28]; 
  int age; 
  int sex; 
  char hobby[28]; 
}; 
 
int main() 
{ 
  int fd; 
  struct userInfo myAddrBook; 
  int dataSize; 
  fd = open("hello.txt", O_RDONLY); 
  if (fd < 0) 
  { 
    perror("file open error"); 
    return 1; 
  } 
 
  dataSize = sizeof(myAddrBook); 
  printf("User Info =====================\n\n"); 
  while(read(fd, (void *)&myAddrBook, dataSize) == dataSize) 
  { 
    printf("name  : %s\n", myAddrBook.name); 
    printf("age   : %d\n", myAddrBook.age); 
    printf("sex   : %d\n", myAddrBook.sex); 
    printf("hobby : %s\n", myAddrBook.hobby); 
    printf("===============================\n"); 
  } 
  close(fd); 
  return 0; 
} 
 

9 파일의 권한과 모드

# ls -al 
-rw-r--r--  1 yundream yundream 4806656 2006-07-28 14:00 My_sweet_darlin.mp3 
drwxr-xr-x  5 yundream yundream    4096 2007-07-29 01:26 PicasaDocuments 
-rwxr-xr-x  1 yundream yundream    7402 2007-11-26 00:01 UserInfoRead 
-rw-r--r--  1 yundream yundream     751 2007-11-26 00:02 UserInfoRead.c 
-rwxr-xr-x  1 yundream yundream    7433 2007-11-25 23:33 UserInfoWrite 
-rw-r--r--  1 yundream yundream    1087 2007-11-25 23:56 UserInfoWrite.c 
drwxr-xr-x  2 yundream yundream    4096 2007-07-31 23:51 backup 
 

10 파일의 종류와 권한,모드 알아내기

struct stat { 
    dev_t         st_dev;      /* device */ 
    ino_t         st_ino;      /* inode */ 
    mode_t        st_mode;     /* protection */ 
    nlink_t       st_nlink;    /* number of hard links */ 
    uid_t         st_uid;      /* user ID of owner */ 
    gid_t         st_gid;      /* group ID of owner */ 
    dev_t         st_rdev;     /* device type (if inode device) */ 
    off_t         st_size;     /* total size, in bytes */ 
    blksize_t     st_blksize;  /* blocksize for filesystem I/O */ 
    blkcnt_t      st_blocks;   /* number of blocks allocated */ 
    time_t        st_atime;    /* time of last access */ 
    time_t        st_mtime;    /* time of last modification */ 
    time_t        st_ctime;    /* time of last change */ 
}; 
 

• st_ino : 파일의 일련번호다. 이 번호는 하나의 장치에서 유일하게 존재하며, 파일과 파일을 구분하게 해준다. 하나의 장치에서만 유일하다는 것에 주의하기 바란다.
  
• st_dev : 파일이 속한 장치의 식별번호다. st_ino 와 st_dev 의 쌍은 전체 시스템에서 유일하다.
  
• st_nlink : 파일의 hard link(이하 하드링크)의 갯수를 알려준다. 하드링크에 대한 내용은 따로 자세히 다루도록 하겠다.
  
• st_mode : 파일의 형식을 알려준다. 이 값을 이용해서, 파일이 디렉토리인지, 링크인지, 장치 파일인지등을 알아낼 수 있다. 이 값을 분석하기 위한 다음과 같은 메크로를 제공한다. 각 메크로는 검사하고자 하는 내용이 참이면 0이 아닌 값을 리턴한다.
  
  1. S_ISDIR(st_mode) : 파일이 디렉토리 인지 검사한다.
     
  2. S_ISCHR(st_mode) : 파일이 문자장치 파일인지 검사한다.
     
  3. S_ISREG(st_mode) : 일반파일인지 검사한다.
     
  4. S_ISFIFO(st_mode) : FIFO 혹은 pipe 파일인지 검사한다.
     
  5. S_ISLNK(st_mode) : symbolic 링크 인지 검사한다.
     
  6. S_ISSOCK(st_mode) : 소켓 파일인지 검사한다.
     
     

#include <unistd.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <pwd.h> 
#include <grp.h> 
 
int main(int argc, char **argv) 
{ 
    int return_stat; 
    char *file_name; 
    struct stat file_info; 
 
    mode_t file_mode; 
 
    if (argc != 2 ) 
    { 
        printf("Usage : ./file_info [file name]\n"); 
        exit(0); 
    } 
    file_name = argv[1]; 
 
    if ((return_stat = stat(file_name, &file_info)) == -1) 
    { 
        perror("Error : "); 
        exit(0); 
    } 
 
    file_mode = file_info.st_mode; 
    printf("파일이름 : %s\n", file_name); 
    printf("=======================================\n"); 
    printf("파일 타입 : "); 
    if (S_ISREG(file_mode)) 
    { 
        printf("정규파일\n"); 
    } 
    else if (S_ISLNK(file_mode)) 
    { 
        printf("심볼릭 링크\n"); 
    } 
    else if (S_ISDIR(file_mode)) 
    { 
        printf("디렉토리\n"); 
    } 
    else if (S_ISCHR(file_mode)) 
    { 
        printf("문자 디바이스\n"); 
    } 
    else if (S_ISBLK(file_mode)) 
    { 
        printf("블럭 디바이스\n"); 
    } 
    else if (S_ISFIFO(file_mode)) 
    { 
        printf("FIFO\n"); 
    } 
    else if (S_ISSOCK(file_mode)) 
    { 
        printf("소켓\n"); 
    } 
 
    printf("OWNER : %d\n", file_info.st_uid); 
    printf("GROUP : %d\n", file_info.st_gid); 
    printf("dev   : %d\n", file_info.st_dev); 
    printf("inode : %d\n", file_info.st_ino); 
    printf("FILE SIZE IS : %d\n", file_info.st_size); 
    printf("마지막 읽은 시간 : %d\n", file_info.st_atime); 
    printf("마지막 수정 시간 : %d\n", file_info.st_mtime); 
    printf("하드링크된 파일수 : %d\n", file_info.st_nlink); 
} 
 

$ ./stat stat.c 
파일이름 : stat.c 
======================================= 
파일 타입 : 정규파일 
OWNER : 1000 
GROUP : 1000 
dev   : 2051 
inode : 6603353 
FILE SIZE IS : 1692 
마지막 읽은 시간 : 1196074251 
마지막 수정 시간 : 1196074249 
하드링크된 파일수 : 2 
 

10.1 hard link와 symbolic link

# ln -s /usr/local/openoffice/bin/openoffice_swrite /usr/bin/swrite  
 

$ ls -al swrite 
lrwxrwxrwx 1 root root 43 2007-11-26 23:44 swrite -> /usr/local/openoffice/bin/openoffice_swrite 
 

10.2 hard link

# mkdir testdir 
# cp myfile testdir/myfile2 
 

# ls -i myfile  
1131883 myfile  
# ls -i testdir/myfile2 
1163816 testdir/myfile2 
 

# ln mydata.txt /home/dragona 
 

# ls -al mydata.txt 
-rw-r----- 2 yundream yundream 192 2007-11-26 23:57 mydata.txt 
 

11 심볼릭 링크

# ln -s mydata.txt mydataln.txt 
 

# ls -l mydataln.txt  
lrwxrwxrwx 1 yundream yundream 10 2007-11-28 01:49 mydataln.txt -> mydata.txt 
 

12 표준입력 표준출력 표준에러

• 표준입력 : 키보드를 통한 입력
  
• 표준출력 : 모니터로 출력되는 정상 메시지
  
• 표준에러 : 모니터로 출력되는 에러 메시지
  
  

• 표준입력 : 0
  
• 표준출력 : 1
  
• 표준에러 : 2
  
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <unistd.h> 
#include <sys/types.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <string.h> 
 
#define STDIN  0 
#define STDOUT 1 
#define STDERR 2 
 
#define ERRMSG "Devide Not Zero\n" 
int main() 
{ 
  int a; 
  int b; 
  char buf[80]; 
 
  read(STDIN, buf, 80); 
  a = atoi(buf); 
 
  read(STDIN, buf, 80); 
  b = atoi(buf); 
  if (b == 0) 
  { 
    write(STDERR, ERRMSG, strlen(ERRMSG)); 
    return 1; 
  } 
 
  sprintf(buf, "%d / %d = %d\n", a, b, (int)(a/b)); 
 
  write(STDOUT, buf, strlen(buf)); 
  return 0; 
} 
 

• 18
  
  표준입력으로 분자를 입력받는다. 키보드로 부터 입력받는 값은 문자열로 atoi(3) 함수를 이용해서 int형 값으로 변경했다.
  
• 21
  
  표준입력으로 분모를 입력받는다.
  
• 23 ~ 27
  
  나눗셈에서는 분모가 0이 되는걸 허용하지 않고 있다. 그러나 실수로 0을 입력할 수 있으므로, 입력값을 검사해서 0이면 에러메시지를 출력하고 종료하도록 하고 있다. 이때 결과값은 에러메시지 이므로 표준에러를 통해서 출력했다.
  
• 31
  
  나눈 결과값을 표준출력을 이용해서 모니터에 출력한다.
  
  

13 입출력 재지향

# ./stdio > result.txt 
1234 
2 
# cat result.txt 
1234 / 2 = 617 
 

# ./stdio 2> err.txt 
1000 
0 
# cat err.txt 
Devide Not Zero 
 

# ./stdio 2>1&  
 

# ./stdio | grep Not  > err.log 
 

# ./stdio 2>&1 | grep Not > err.log 
1000 
0 
# cat err.log 
Devide Not Zero 
 

# cat sound.wav > /dev/audio 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <unistd.h> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <fcntl.h> 
#include <stdio.h> 
#include <string.h> 
 
#define STDIN  0 
#define STDOUT 1 
#define STDERR 2 
 
int main(int argc, char **argv) 
{ 
  int fd; 
  fd = open("test.log", O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); 
  fd = dup2(fd, STDOUT); 
  printf("Hello World %d\n", fd); 
} 
 

• 15 : 재지향할 파일로 test.log를 오픈했다. fd는 아마도 3일 것이다.
  
• 16 : dup2()함수를 이용해서 fd를 STDOUT로 복사했다.
  
• 17 : printf 함수를 이용해서 표준출력했지만 STDOUT는 test.log의 파일지정자로 복사가 되었기 때문에, 모니터로 출력이 되느넥 아니고 파일로 출력이 된다.
  

14 사용한 함수들 정리

• open(2) : 파일을 연다.
  
• write(2) : 파일을 쓴다.
  
• read(2) : 파일의 내용을 읽는다.
  
• close(2) : 열린 파일을 닫는다.
  
• printf(3) : 문자열을 화면에 표준출력 한다.
  
• dup2(2) : 파일지정번호를 복사한다.
  
• perror(3) : 에러메시지를 표준에러로 출력한다.