프로세스의 실행

• 프로세스 - 실행중인 프로그램, 메모리에 프로그램이 로드된 상태
• PCB - 레지스터 정보, 프로세스 상태 정보, 프로세스의 리소스 정보 등을 한 곳에 모아놓은 정보
• Context Switch - 현재 실행중인 CPU의 PCB를 외부 저장소에 저장하고 다른 PCB를 로드하는 것
  • time-sharing을 하여 동시성 제어를 할 수 있음

Unix 기반 운영체제

• 새로운 프로세스는 fork() system call에 의해 생성됨
• 자식 프로세스는 부모 프로세스의 주소를 복사하여 만들어짐
• 부모 프로세스와 자식 프로세스는 fork() system call 이후의 명령어를 실행함
• fork()의 return code가 0이라면 자식 프로세스
• return code가 0이 아니라면 부모 프로세스

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

int main(){
	pid_t pid;
    pid = fork();
    printf("Hello, Process!\n");
}

• main.c를 compile하여 a.out (program)이 만들어짐
• a.out을 memory에 로드
• 프로세스 상태 정보가 PCB에 저장됨
• fork()를 하면 부모 프로세스와 동일한 주소 공간을 메모리에 복사함
• 부모 프로세스가 끝난 후에도 자식 프로세스는 ready queue에서 대기하고 있음
• 자식 프로세스에서 fork 이후 PC가 printf를 가리켜, 다시 한 번 printf가 실행됨

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

int main(){
	pid_t pid;
    pid = fork();
    printf("Hello, Process! %d\n", pid);
}

• 부모의 프로세스 pid가 먼저 출력 (0 이상의 임의 숫자)
• 자식의 프로세스 pid가 출력 (0)

fork

• 부모 프로세스의 주소 공간을 그대로 복사
• 부모 프로세스는 자기 할 일을 계속 실행함
• wait()를 사용하면 자식 프로세스가 실행되는 동안 wait queue에서 기다릴 수 있음
• 부모 프로세스는 자식 프로세스가 종료될 때까지 대기함

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

int main(){
	pid_t pid;
    pid = fork();
    if (pid > 0)
    	wait(NULL);
    printf("Hello, Process! %d\n", pid);
}

• 부모 프로세스는 $pid >0$이므로 wait하게 됨 → wait queue에서 대기
• 자식 프로세스는 pid가 0이므로 wait하지 않고 실행되어 pid가 출력 (0)
• 자식 프로세스가 종료된 후 부모 프로세스가 CPU를 점유해 pid를 출력 (0 이상의 임의 숫자)

ex1)

int value = 5;

int main(){
	pid_t pid;
    pid = fork();
    
    if (pid == 0){
    	value += 15;
        printf("value in child process is %d\n", value);
        return 0;
    }
    else if(pid > 0){
    	wait(NULL);
        printf("value in parent process is %d\n", value);
    }
}

• 자식 프로세스는 부모 프로세스의 주소 공간을 그대로 복사함 → 변수 value까지 복사가 됨
• 자식 프로세스에서 더한 숫자값은 자식 프로세스에서만 유효하기 때문에 자식 프로세스에서의 value는 20이 됨
• 부모 프로세스에서의 value는 다른 공간에 할당되어 있으므로, value는 그대로 5로 출력

ex2)

int main(){
	fork();
    fork();
    fork();
    
    return 0;
}

• 부모 프로세스 $P_0$가 fork하여 자식 프로세스 $P_1$이 생성
• $P_0$가 다시 fork하여 $P_{2}$ 생성, 자식 프로세스 $P_1$가 fork하여 $P_{11}$이 생성
• $P_0$가 fork하여 $P_3$ 생성, $P_1$이 fork하여 $P_{12}$ 생성, $P_{11}$이 fork하여 $P_{111}$ 생성, $P_2$가 fork하여 $P_{21}$이 생성
• 총 8개의 프로세스가 생성됨

ex3)

int main(){
	int i;
    
    for(i=0;i<4;i++)
    	fork();
    
    return 0;
}

• 부모 프로세스 $P_0$가 fork하여 $P_1$생성
• $P_0$가 fork하여 $P_2$ 생성, $P_1$이 fork하여 $P_{11}$ 생성
• $P_0$가 fork하여 $P_3$ 생성, $P_1$이 fork하여 $P_{12}$ 생성, $P_2$가 fork하여 $P_{21}$ 생성, $P_{11}$이 fork하여 $P_{111}$ 생성
• $P_0$가 fork하여 $P_4$ 생성, $P_1$이 fork하여 $P_{13}$ 생성, $P_2$가 fork하여 $P_{22}$ 생성, $P_3$이 fork하여 $P_{31}$ 생성, $P_{11}$이 fork하여 $P_{112}$ 생성, $P_{12}$가 fork하여 $P_{121}$ 생성, $P_{111}$이 fork하여 $P_{1111}$ 생성, $P_{21}$이 fork하여 $P_{211}$ 생성
• 총 16개의 프로세스가 생성됨

ex4)

int main(){
	printf("L0\n");
    fork();
    
    printf("L1\n");
    fork();
    
    printf("Bye\n");
}

출력
L0
L1
L1
Bye
Bye
Bye
Bye

생성된 자식 프로세스와 부모 프로세스는 동시에 실행되고, 프로세스 생성 및 스케쥴링에 따라 출력 순서는 달라질 수 있음

ex5)

int val = 5;

int main(){
	fork();
    val += 5;
    printf("val is %d\n", val);
    
    fork();
    val += 5;
    printf("val is %d\n", val);
    
    fork();
    val += 5;
    printf("val is %d\n", val);
    
    return 0;
}

출력
10
10
15
15
15
15
20
20
20
20
20
20
20
20

• 출력 순서는 스케쥴링에 따라 달라질 수 있음
• fork한 이후의 코드는 부모 프로세스와 자식 프로세스 모두에 대해 수행해주면 됨

ex6)

int main(){
	pid_t pid;
    pid = fork();
    
    if (pid == 0){
    	execlp("/bin/ls", "ls", NULL);
        printf("LINE J\n");
    }
    else if (pid > 0){
    	wait(NULL);
        printf("Child Complete\n");
    }
    
    return 0;
}

• fork()를 사용하면 부모 프로세스와 동일한 주소 공간을 복사하게 됨
• 여러 개의 프로세스를 사용하는 이유는 서로 다른 프로그램을 동시에 돌리기 위함임
• execlp()를 사용하면 fork()를 이용해 복사된 공간에 다른 프로그램을 덮어쓸 수 있음

출력
{ls} 내역
Child Complete

→ "LINE J"라는 텍스트가 출력되지 않음

• execlp를 사용하면 뒤에 오는 명령어들은 실행되지 않음

ex7)

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

int main(){
        pid_t pid, pid1;
        pid = fork();

        if (pid == 0){
                printf("child process\n");
                pid1 = getpid();
                printf("child: pid = %d\n", pid);
                printf("child: pid1 = %d\n", pid1);
                puts("");
        }
        else if (pid > 0){
                wait(NULL);
                printf("parent process\n");
                pid1 = getpid();
                printf("parent: pid = %d\n", pid);
                printf("parent pid1 = %d\n", pid1);
                puts("");
        }

        return 0;
}

• child pid는 자식 프로세스의 반환값 0
• child pid1은 자식 프로세스의 pid인 0보다 큰 값
• parent pid는 생성된 자식 프로세스의 pid인 0보다 큰 값
• child pie1과 parent pid는 동일한 값을 가짐
• parent pid1은 부모 프로세스의 pid

ex8)

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

#define SIZE 5

int nums[SIZE] = {0, 1, 2, 3, 4};

int main(){
        pid_t pid;
        int i;
        pid = fork();

        if (pid == 0){
                for(i=0;i<SIZE;i++){
                        nums[i] *= i;
                        printf("CHILD: %d\n", nums[i]);
                }
        }
        else if (pid > 0){
                wait(NULL);
                for(i=0;i<SIZE;i++)
                        printf("PARENT: %d\n", nums[i]);
        }
}

복사된 자식 프로세스에서는 0, 1, 4, 9, 16를, 부모 프로세스에서는 0, 1, 2, 3, 4를 출력하게 된다