[42seoul] philosophers

Philosophers

Overview

과제를 하기 전 알아야 할 것! :

• 하나 이상의 철학자가 둥근 테이블에 앉아 가운데 있는 스파게티를 먹음
• 철학자는 eat, think, sleep 중 하나의 상태를 취하고 있음
• 철학자의 수 만큼 포크가 있음. 꼭 양손으로 포크 두개를 잡고 먹어야 한대…
• 철학자가 eating을 끝내면 sleeping 시작, 일어나면 thinking 함. 이 시뮬레이션은 철학자가 굶어 죽으면 종료
• 모든 철학자는 먹어야 하고 굶으면 안돼!
• 철학자는 서로 얘기하지 않음, 서로 죽을 위기에 있다는 것도 모름
• 철학자가 죽는 것을 피하자..

Global rules

• 전역 변수 금지

• 프로그램이 인자로 받는 것 :

  1. number_of_philosophers : 철학자 수 == 포크 개수
  2. time_to_die(단위:ms) : 이 시간만큼 밥을 못먹으면 죽음
  3. time_to_eat (ms) : 먹는데 걸리는 시간 (먹을 때 포크는 꼭 두개씩 쓴댜… 왜그러는겨대체 )
  4. time_to_sleep (ms) : 자는데 걸리는 시간
  5. number_of_times_each_philosopher_must_eat (optional argument) : 모든 철학자가 주어진 횟수 이상 밥을 먹으면 시뮬레이션 종료. 이 인자가 없다면 철학자가 죽을 때 시뮬레이션이 종료함

• 각 철학자들은 1 ~ n 의 번호가 매겨짐. k={1≤k≤n}일때, k번 철학자는 k-1과 k+1 번 철학자 사이에 앉음

• 프로그램의 로그:

• 철학자의 상태 변화는 아래와 같은 형식이어야 함

  • timestamp_in_ms X has taken a fork

  • timestamp_in_ms X is eating

  • timestamp_in_ms X is sleeping

  • timestamp_in_ms X is thinking

  • timestamp_in_ms X died

  • timestamp_in_ms는 현재 miliseconds, X는 철학자 번호*

❗ data race가 발생해서는 안된다

Mendatory part

mandatory part rule

• 각 철학자는 스레드임
• 두 철학자 사이에 포크 하나가 존재. 철학자가 한명이라면 포크도 한개(죽음)
• 포크 상태를 뮤텍스로 보호하기

Thread

: 프로세스 내에서 실행되는 여러 흐름의 단위

• 스레드는 프로세스 내에서 stack만 따로 할당받고 code, data, heap 영역을 공유한다.
• 멀티 프로세스보다 멀티 스레딩이 context switching 비용이 적다.
• [동기화] 문제를 주의해야함

Synchronization (동기화)

• 다중 프로세스 혹은 다중 스레드가 하나의 자원에 접근할 경우 동기화 문제 발생

mandatory 허용 함수 설명

pthread.h의 함수들을 컴파일 할 때, -lpthread 플래그를 사용해야 함

• pthread_create : thread를 생성

    int pthread_create(pthread_t *thread, 
                                        const pthread_attr_t *attr,
                                        void *(*start_routine)(void *), 
                                        void *arg);

  return 값 : 성공적으로 pthread 가 만들어진 경우 0을 반환하고 thread에 식별자를 담아줌

  *thread : thread의 식별자

  *attr : thread의 속성 (NULL로 넣으면 default 설정으로)

  *start_routine : thread가 실행할 함수 포인터

  *arg : start_routine에 들어갈 인자

• pthread_join : 스레드가 종료될 때까지 기다림

    int pthread_join(pthread_t thread, void **value_ptr);

  return 값 : 성공시 0, 실패시 오류코드

  void **value_ptr : thread의 return value

• pthread_detach : pthread를 부모 pthread로부터 독립시킴

    int pthread_detach(pthread_t thread);

  return 값 : 성공 시 0, 오류시 오류코드

• thread 사용 연습

    #include <pthread.h>
    #include <stdio.h>
    #include <unistd.h>
  
    void    *routine1(void *arg)
    {
        int num = *(int *)arg;
  
        while (num < 5)
        {
            printf("I'm t1! %d\n", num);
            usleep(30);
            num++;
        }
        printf("t1 finished!\n");
        *(int *)arg =  num;
        return (NULL);
    }
  
    void    *routine2(void *arg)
    {
        int num = *(int *)arg;
  
        while (num < 5)
        {
            printf("I'm t2! %d\n", num);
            usleep(30);
            num++;
        }
        printf("t2 finished!\n");
        *(int *)arg = num;
        return (NULL);
    }
  
    int main(void)
    {
        pthread_t t1;
        pthread_t t2;
  
        int arg1 = 1;
        int arg2 = 1;
  
        pthread_create(&t1, NULL, routine1, (void *)&arg1);
        pthread_create(&t2, NULL, routine2, (void *)&arg2);
        pthread_join(t1, NULL);
        pthread_join(t2, NULL);
        printf("t1 : %d, t2 : %d \n", arg1, arg2);
        return (0);
    }

  —> 출력결과

    kimjiyoon@gimjiyun-ui-MacBookPro 42Seoul % !.
    ./a.out
    I'm t1! 1
    I'm t2! 1
    I'm t1! 2
    I'm t2! 2
    I'm t1! 3
    I'm t2! 3
    I'm t1! 4
    I'm t2! 4
    t1 finished!
    t2 finished!
    t1 : 5, t2 : 5

• pthread_mutex_init : mutex 초기화

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

• pthread_mutex_destroy : mutex 파기 or 초기화 되기 전으로 돌리기

    int pthread_mutex_destroy(pthread_mutex_t *mutex);

  mutex를 destroy하고 init으로 다시 초기화 해줄 수 있음

• pthread_mutex_lock : mutex 잠금

  pthread_mutex_unlock : mutex 잠금 해제

    int pthread_mutex_lock(pthread_mutex_t *mutex);
    int pthread_mutex_unlock(pthread_mutex_t *mutex);