1. Bounded-Buffer Problem : 공유버퍼 문제 (Producer-Consumer Problem)

Producer : 데이터를 넣어주는 생산자

Comsumer : 데이터를 사용하는 소비자

발생하는 문제

1) 복수의 생산자 동시접근

2) 복수의 소비자 동시접근

3) 버퍼가 꽉 차있을 때 생산자의 접근

4) 버퍼가 비어있을 때 소비자의 접근

 

Shared data]

buffer 자체 및 buffer 조작 변수(empty/full buffer의 시작 위치)

Synchronization variables]

mutual exclusion : need binary semaphore (공유데이터의 상호배제를 위해(자원 접근 넣고 빼기))

resource count : need integer semaphore (남은 full/empty buffer 수 표시를 위해(가용자원에 대한 문제))

 

Synchronization variables
semaphore full = 0, empty = n, mutex = 1; // lock을 거는용 mutex, 비어있는 변수 empty, 내용있는 버퍼 full

Producer
do {
   P(empty);    //빈 버퍼 확인 후 기다리거나 획득하거나
   P(mutex);    //버퍼 획득시 lock 걸기
   add x to buffer
   V(mutex);   //버퍼 반납 후 lock 풀기
   V(full);       //데이터 넣은 버퍼 갯수 증가
} while(1);

Consumer
do {
   P(full);       //데이터 있는 버퍼 확인 후 기다리거나 획득하거나
   P(mutex);   //버퍼 획득시 lock 걸기
   remove an item from buffer to y
   V(mutex);   //버퍼 반납 후 lock 풀기
   V(empty);   //비어있는 버퍼 갯수 증가
} while(1);

 

2. Readers-Writers Problem : 읽고 쓰기 문제

한 프로세스가 DB에 write 중일 때 다른 process가 접근하면 안된다

read는 동시에 여럿이 해도 된다

solution

- writer가 DB에 접근 허가를 아직 얻지 못한 상태에서는 모든 대기중인 reader들을 다 DB에 접근하게 해준다

- writer는 대기 중인 reader가 하나도 없을 때 DB접근이 허용된다

- writer가 DB에 접근 중이면 reader들은 접근이 금지된다

- writer가 DB에서 빠져나가야만 reader의 접근이 허용된다

 

Shared data]

DB 자체

readcount (현재 DB에 접근 중인 reader 의 수)

Synchronization variables]

mutex : 공유 변수 readcount를 접근하는 코드(critical section)의 mutual exclusion 보장을 위해 사용

db : reader 와 writer 가 공유 DB 자체를 올바르게 접근하게 하는 역할

Shared data
int readcount = 0;
DB 자체;
Synchronization variables
semaphore mutex=1, db=1; //mutex 는 readcount 에 대한 lock 용, db는 DB lock 용

Writer
P(db);  // Starvation 발생 가능 (Reader 가 계속 들어와서 존재할 경우 Writer 순서가 오지 않음)
writing DB is performed
V(db);

Reader
P(mutex); // readcount 도 mutex 가 보장되어야 하므로 readcount lock시킨다
readcount++;
if(readcount==1) P(db); //block writer : 최초의 reader 접근시 writer lock시킨다
V(mutex); //readers follow
reading DB is performed
P(mutex);
readcount--;
if(readcount == 0) V(db);  //enable writer (writer lock을 푼다)
V(mutex);

 

3. Dining-Philosophers Problem

Dead lock 의 가능성

해결방안 :

1) 최대 4명만 동시에 테이블에 앉도록

2) 젓가락을 두 개 모두 집을 수 있을 때만 젓가락을 집을 수 있게 한다

3) 짝수(홀수) 철학자는 왼쪽(오른쪽) 젓가락부터 집도록

 

2번 해결방안에 대한 코드]

 

Semaphore의 문제점

- 코딩하기 힘들다

- 정확성(correctness)의 입증이 어렵다

- 자발적 협력(voluntary cooperation)이 필요하다

- 한번의 실수가 모든 시스템에 치명적 영향을 준다

실수의 예]

 

Monitor

: 동시 수행중인 프로세스 사이에서 abstract data type의 안전한 공유를 보장하기 위한 high-level synchronization construct (java 디자인 패턴에서 어댑터 패턴을 사용하여 세마포를 캡슐화한 어댑터와 비슷한 느낌)

- 모니터 내에서는 한번에 하나의 프로세스만이 활동 가능

- 프로그래머가 동기화 제약 조건을 명시적으로 코딩할 필요없음

- 프로세스가 모니터 안에서 기다릴 수 있도록 하기 위해 condition variable 사용

- Condition variable 은 wait과 signal 연산에 의해서만 접근 가능

x.wait()

: x.wait()을 invoke한 프로세스는 다른 프로세스가 x.signal()을 invoke하기 전까지 suspend 된다

x.signal()

: x.signal()은 정확하게 하나의 suspend 된 프로세스를 resume 한다

Suspend된 프로세스가 없으면 아무 일도 일어나지 않는다

 

monitor 를 사용한 bounded buffer 문제 해결 코드]

monitor bounded_buffer
{
   int buffer[N];
   condition full, empty;
   // condition var은 값을 가지지 않고 자신의 큐에 프로세스를 매달아서 sleep 시키거나
   // 큐에서 프로세스를 깨우는 역할만 함

   void produce(int x){
      empty.wait(); // if there is no empty buffer 
      full.signal(); // add x to an empty buffer
   }
   void consume(int x){
      full.wait(); // if there is no full buffer
      empty.signal(); // remove an item from buffer and store it top x
   }
}

monitor 를 사용한 dining philosopher 문제 해결 코드]

 

※ 이화여대 반효경 교수님의 운영체제 강의 정리

반응형

Semaphores 

임계영역 문제를 해결하기 위한 알고리즘(참고)들을 추상화 시킴

 

[Semaphore S]

integer variable

아래 두가지 atomic 연산에 의해서만 접근 가능

 

P(S) 자원 있으면 가져감

while(S<=0) do no-op;  //wait : busy-wait
S--;

V(S) 반납

S++;

 

[세마포를 사용한 임계영역문제 해결 : busy-wait (=spin lock)]

Synchronization variable
semaphore mutex; // mutual exclusion

do {
   P(mutex);        // if positive, decrement & enter, otherwise, wait
   critical section
   V(mutex);        // Increment semaphore
   remainder section
} while(1);

 

[세마포를 사용한 임계영역문제 해결 : block-wakeup]

Semaphore 정의]
여기서 value는 상호배제를 위한 flag용도가 아닌 가용한 자원의 수

typedef struct
{
   int value;             // semaphore
   struct process *L;   // process wait queue
}

block 과 wakeup을 다음과 같이 가정]

block :

커널은 block을 호출한 프로세스를 suspend 시킨다

이 프로세스의 PCB를 semaphore에 대한 wait queue에 넣는다

 

wakeup(P) :

block된 프로세스 P를 wakeup 시킨다

이 프로세스의 PCB를 ready queue로 옮긴다

 

 

P(S)

S.value--;
if(S.value < 0){
   add this process to S.L;
   block();
}

V(S)
부등호가 <= 인 이유는,
value가 0보다 작을 경우 자원을 기다리는 프로세스가 있음을 의미하므로 value가 0보가 작을 때 wake up 함

S.value++;
if(S.value <= 0){
   remove a process P from S.L;
   wakeup(P);
}

일반적으로 Busy-wait보단 Block/wakeup를 사용

Critical section 길이가 매우 짧은 경우 Block/wakeup 오버헤드가 busy-wait 오버헤드보다 더 커질 수도 있다

 

[ 두가지 유형의 Semaphores ]

1) Counting semaphore 

도메인이 0 이상인 임의의 정수값

주로 resource counting(가용한 자원 수 카운트용)에 사용

 

2) Binary semaphore (=mutex)

0 또는 1 값만 가질 수 있는 semaphore

주로 mutual exclusion (lock/unlock)에 사용

 

※ Deadlock (교착상태)

둘 이상의 프로세스가 서로 상대방에 의해 충족될 수 있는 event를 무한히 기다리는 현상

 

※ Starvation (기아)

indefinite blocking.

세마포어 큐에서 빠져나갈 수 없는 현상

(deadlock 도 일종의 starvation)

 

[Deadlock, Starvation의 예 : Dining-Philosophers Problem]

 

한 사람이 양쪽의 젓가락 한짝씩 들어서 한 쌍을 만들어야 식사가 가능하다고 할 때,

Dead lock 은 모든 사람들이 자신의 자리에서 오른쪽(왼쪽) 젓가락을 사용하여 모두가 식사를 시작하지 못하는 상황

Starvation 은 사람 A의 좌우 사람이 젓가락을 가지고 식사를 하여 A 가 식사를 시작하지 못하는 상황

 

 

※ 이화여대 반효경 교수님의 운영체제 강의 정리

반응형

[Process Synchronization]

공유 데이터(shared data)의 동시 접근(concurrent acecss)은 데이터의 불일치 문제(inconsistency)를 발생시킬 수 있다

일관성(consistency)를 위해 협력프로세스간의 실행순서를 정해주는 메커니즘이 필요

 

[Race condition]

여러 프로세스들이 동시에 공유데이터를 접근하는 상황

데이터의 최종 연산 결과는 마지막에 그 데이터를 다룬 프로세스에 따라 달라진다

 

=> race condition을 막기 위해 concurrent process는 동기화(synchronize) 되어야 한다

 

Process 가 한 개 있는 경우

Process가 두 개 있는 경우

S-box(memory address space)를 공유하는 E-box(CPU process)가 여럿 있는 경우,

Race Condition의 가능성이 있다

 

[OS에서 race condition이 발생하는 경우]

1) interrupt handler v.s. kernel

커널모드 running 중 interrupt가 발생하여 인터럽트 처리루틴이 수행

커널모드 running 중 interrupt 가 발생하여 인터럽트 처리루틴이 수행

해결책 : 처리가 완료되기 전까지 interrupt를 받아주지 않는다

 

2) preempt a process running in kernel

해결책 : 커널모드에서 수행 중일 때는 CPU를 preempt(선점) 하지 않음. 커널 모드에서 사용자 모드로 돌아갈 때 preempt

 

3) multiprocessor

multiprocessor의 경우 위의 케이스들과 달리 interrupt enable/disable로 해결되지 않는다.

해결책 1) 한번에 하나의 CPU만이 커널에 들어갈 수 있게 하는 방법

해결책 2) 커널 내부에 있는 각 공유데이터에 접근할 때마다 그 데이터에 대한 lock/unlock을 하는 방법

 

 

The Critical-Section problem : 임계영역 문제

n개의 프로세스가 공유 데이터를 동시에 사용하기를 원하는 경우

각 프로세스의 code segment에는 공유 데이터를 접근하는 코드인 critical section이 존재

problem : 하나의 프로세스가 critical section에 있을 때 다른 모든 프로세스는 critical section에 들어갈 수 없어야 한다

 

 

프로그램적 해결법의 충족 조건

1) Mutual Exclusion (상호배제)

프로세스가 critical section 부분을 수행 중이면 다른 모든 프로세스들은 그들의 critical section에 들어가면 안된다

2) Progress

아무도 critical section에 있지 않은 상태에서 critical section에 들어가고자 하는 프로세스가 있으면 critical section에 들어가게 해주어야 한다

3) Bounded Waiting(유한한 대기)

프로세스가 ciritical section에 들어가려고 요청한 후부터 그 요청이 허용될 때까지 다른 프로세스들이 critical section에 들어가는 횟수에 한계가 있어야 한다(starvation 방지)

 

[Critical Section problem 해결 알고리즘 1]

Process0 이 한 번 수행으로 끝이난 경우 Process1 은 다시 들어갈 수 없음

(타 프로세스가 turn 을 내 값으로 바꿔줘야만 내가 들어갈 수 있기 때문) : 과잉양보 발생

-> mutual exclusion 은 만족하나 progress 는 만족하지 않음

 

Process0]

do {
   while(turn != 0);    // my turn?
   critical section
   turn = 1;
   remainder section  // now it's your turn
} while(1)

Process1]

do { 
   while(turn != 1); // my turn?
   critical section 
   turn = 0;
   remainder section  // now it's your turn
} while(1)

[Critical Section problem 해결 알고리즘 2]

두 프로세스가 2행까지(while문) 수행 후 끊임 없이 양보하는 상황 발생 가능

(critical section 진입 후 flag를 false 로 두어 나왔음을 알리지만 2행까지 실행된 경우 두 프로세스가 loop가 돌며 계속 양보하게 되므로)

Process0, Process1]

do {
   flag[i] = true;   //pretend I am in
   while(flag[j]);    //is he also in? then wait
   critical section
   flag[i] = false;   // i am out now
   remainder section
} while(1);

 

[Critical Section problem 해결 알고리즘 3]

Peterson's Algorithm

Mutual Exclusion, Progress, Bounded waiting 을 모두 만족

하지만 Busy waiting(=spin lock=loop) : CPU , memory 를 계속 사용하며 wait 

Process0]

do {
   flag[0] = true;   //My intention is to enter
   turn = 1;          // set to his turn
   while(flag[1] && turn == 1);    // wait only if
   critical section
   flag[0] = false;
   remainder section
} while(1);

Process1]

do {
   flag[1] = true;  //My intention is to enter
   turn = 0;        // set to his turn
   while(flag[0] && turn == 0);     // wait only if
   critical section
   flag[1] = false;
   remainder section
} while(1);

하드웨어적으로 Test와 Modify를 atomic 하게(읽기와 쓰기를 한번에(하나의 instruction으로)) 수행할 수 있도록 지원하는 경우 앞의 문제는 간단히 해결

: interrupt 등으로 프로세스가 CPU를 뺏길 때, 실행 하던 instruction은 끝마치고(라인 한 줄) 뺏긴다.

instruction 을 한 줄이 아닌 두개의 instruction 으로 지원하여 instruction+flag처리를 한 번에 다룰 경우, 임계영역에 대한 처리가 간단해진다

Synchronization variable :
boolean lock = false;

do {
   while(Test_and_Set(lock)); 
   critical section
   lock = false;
   remainder section
}

 

※ 이화여대 반효경 교수님의 운영체제 강의 정리

반응형

CPU Scheduling 

CPU를 누구에게 줄것인가, 주고나서 뺏어올 것인가

 

 CPU and I/O Bursts in program execution

사용자와의 interaction 이 많은 프로그램일 수록 I/O burst 높다

 

 

 CPU-burst Time의 분포

I/O bound job : I/O 많이 사용, many short CPU bursts

CPU bound job : CPU 많이 사용(계산 위주의 job), few very long CPU bursts.

-> 여러 종류의 job(process)이 섞여 있기 때문에 CPU 스케쥴링이 필요.

 

 CPU Scheduler & Dispatcher

- CPU Scheduler :

Ready 상태의 프로세스 중에서 이번에 CPU를 줄 프로세스를 고른다(OS 안에서 처리됨, 별도의 하드웨어나 소프트웨어가 아님)

- Dispatcher :

CPU 제어권을 CPU scheduler 에 의해 선택된 프로세스에게 넘긴다

이 과정을 context switch(문맥 교환)라고 한다

 

 CPU 스케쥴링이 필요한 경우

1. Running -> Blocked (ex: I/O 요청하는 시스템 콜) : 자진 반납(nonpreemptive)

2. Terminate : 자진 반납(nonpreemptive)

3. Blocked -> Ready (ex: I/O완료 후 interrupt) : 강제 반납(preemptive)

4. Running -> Ready (ex: 할당시간만료로 timer interrupt) : 강제 반납(preemptive)

 

 

Scheduling Criteria

: Performance Index(=Performance Measure, 성능척도)

1. CPU utillization (이용료)

: Keep the CPU as busy as possible (ex: 주방장이 일하는 시간)

2. Throughput (처리량)

: # of processes that complete their execution per time unit

(ex: 얼마나 많은 손님이 다녀갔는가)

3. Turnaround Time (소요시간, 평균시간)

: amount of time to execute a particular process

cpu 처리시간의 총합

(ex: 손님이 와서 식사 하는 시간의 총합(코스요리의 경우 먹고 쉬고 먹고 쉬고를 반복, 먹는 시간의 합))

4. Waiting time (대기 시간)

: amount of time a process has been waiting in the ready queue

(ex: 손님이 와서 기다리는 시간의 총합(코스요리))

5. Response time (응답 시간)

: amount of time it takes from when a request was submitted until the first response is produced, not output

처음으로 응답되는데 까지 걸리는 시간

(ex: 손님이 와서 밑반찬을 네주는데 걸리는 시간)

 

1, 2 는 시스템 입장에서 CPU 성능척도

3, 4, 5 는 process 입장에서의 성능척도

 

 

CPU Scheduling 종류

1. FCFS(First-Come First-Served)

프로세스 도착 순서대로 처리(비선점형 nonpreemptive)

문제점

Convoy effect : short process behind long process

앞에 긴 프로세스가 존재하여 뒤에 짧은 프로세스가 처리되지 못하는 현상

 

2. SJF(Shortest-Job-First)

- 각 프로세스와 다음번 CPU burst time을 가지고 스케쥴링에 활용

- CPU burst time이 가장 짧은 프로세스를 제일 먼저 스케쥴

1) Nonpreemptive

CPU를 잡으면 이번 CPU burst가 완료될 때까지 CPU를 뺏기지 않음

2) Preemptive

현재 수행중인 프로세스의 남은 burst time보다 더 짧은 CPU burst time 을 가지는 새로운 프로세스가 도착하면 CPU를 빼앗긴다. 이를 SRTF(Shortest-Remaining-Time-First)라고 부른다.

- SJF is optimal(최적화) : 주어진 프로세스에 대해 minimum average waiting time을 보장

 

※ CPU Burst Time의 예측

- 다음번 CPU burst time 은 추정(estimate)만 가능

- 과거의 CPU burst time 을 이용해서 추정 (exponential averaging)

CPU Burst Time 예측 공식 정리가 되어있는 곳 : https://darkluster.tistory.com/43

 

3. Priority Scheduling

- A priority number(integer) is associated with each process

- 가장 높은 우선수위를 가진 프로세스에게 CPU 할당(smallest integer = highest priority)

- SJF 는 일종의 priority scheduling

문제점

Starvation(기아현상)

: low priority processes may never execute. (낮은 우선순위 프로세스가 영원히 CPU를 얻지 못하는 것)

※ 해결책

Aging(노화)

: as time progresses increase the priority of the process (시간이 지나면 우선순위를 올려주는 것)

 

4. Round Robin(RR)

- 각 프로세스는 동일한 크기의 할당 시간(time quantum)을 가진다 (일반적으로 10-100milliseconds)

- 할당 시간이 지나면 프로세스는 선점(preempted) 당하고 ready queue와 제일 뒤에 가서 다시 줄을 선다

- n 개의 프로세스가 ready queue에 있고 할당 시간이 q time unit 인 경우 각 프로세스는 최대 q time unit 단위로 CPU 시간의 1/n을 얻는다 (어떤 프로세스도 (n-1)q time unit 이상을 기다리지 않는다)

 장점

1) 응답시간이 빠르다.

2) CPU가 길게 필요하면 길게 기다리고, 짧게 필요하면 짧게 기다린다. (짧은 프로세스는 빨리 나가고 긴 프로세스는 길게(많이) 기다리게 되므로 프로세스의 waiting time 과 turnaround time 이 비례)

할당시간에 따른 차이

q large (할당시간이 길다면) => FCFS

q small (할당시간이 짧다면)=> context switch 오버헤드가 커진다.

 

Multilevel Queue

Queue가 여러줄이며 우선순위가 높은 큐의 프로세스가 CPU 우선권을 가진다

1) Ready queue를 여러개로 분할

  - foreground (interactive(IO))

  - background(batch - no human interaction)

2) 각 큐는 독립적인 스케쥴링 알고리즘을 가진다

  - foreground - RR (빠른 응답속도)

  - background - FCFS

3) 큐에 대한 스케쥴링 필요

  - Fixed priority scheduling : starvation 문제

  - Time slice : 각 큐에 CPU time을 적절한 비유로 할당한다

    80% to foreground in RR, 20% to background in FCFS

 

Multilevel Feedback Queue

프로세스 처리가 끝나면 바로 나감, 처리가 끝나지 못하면 두번째 큐로 이동, 또 처리가 되지 못했다면 맨 밑의 큐로 이동

처리가 짧은 프로세스에게 우선권을 먼저 준다

 

Multiple-Processor Scheduling

CPU가 여러개인 경우

1) Homogeneous processor 인 경우

- Queue에 한 줄로 세워서 각 프로세서가 알아서 꺼내가도록

- 반드시 특정 프로세서에서 수행되어야 하는 프로세스가 있는 경우 문제가 복잡해진다

2) Load sharing

- 일부 프로세서에 job이 몰리지 않도록 부하를 적절히 공유하는 메커니즘 필요

- 별개의 큐를 두는 방법 vs. 공동 큐를 사용하는 방법

3) Symmetric Multiprocessing(SMP)

- 각 프로세서가 각자 알아서 스케쥴링 결정

4) Asymmetric multiprocessing

- 하나의 프로세서가 시스템 데이터의 접근과 공유를 책임지고 나머지 프로세서는 거기에 따름

 

Real-Time Scheduling

1) Hard real-time systems : 정해진 시간안에 반드시 끝내도록 스케쥴링

2) Soft real-time computing : 일반 프로세스에 비해 높은 우선순위를 갖도록 해야 한다

 

3. Thread Scheduling

1) Local Scheduling : User level thread 의 경우 사용자 수준의 thread library에 의해 어떤 thread 를 스케쥴할 지 결정

2) Global Scheduling : Kernel level thread 의 경우 일반 프로세스와 마찬가지로 커널의 단기 스케쥴러가 어떤 thread 스케쥴할지 결정 

 

 

Algoritm Evaluation 알고리즘 평가방법

1) Queueing models

확률 분포로 주어지는 arrival rate와 service rate 등은 통해 각종 performance index 값을 계산

2) Implementation (구현) & Measurement (성능 측정)

실제 시스템에 알고리즘을 구현하여 실제 작업(workload)에 대해서 성능을 측정 비교

3) Simulation (모의 실험)

알고리즘을 모의 프로그램으로 작성 후 trace를 입력하여 결과 비교

 

 

※ 이화여자대학교 반효경 교수님의 운영체제 강의 정리

반응형

프로세스 생성

1. 부모 프로세스가 자식 프로세스를 생성

   (COW : Copy-On-Write 자식은 부모 자원을 그대로 공유하여 사용하고 있다가 write 발생할 경우 복사 함)

2. 프로세스의 트리 형성

3. 프로세스는 자원을 필요로 함

  - 운영체제로 부터 받는다

  - 부모와 공유한다

4. 자원의 공유

  1) 부모와 자식이 모든 자원을 공유하는 모델

  2) 일부를 공유하는 모델

  3) 전혀 공유하지 않는 모델

5. 수행(Execution)

 - 부모와 자식은 공존하며 수행되는 모델

 - 자식이 종료(terminate)될 때까지 부모가 기다리는(wait) 모델

 

주소 공간(Address space)

 - 자식은 부모의 공간을 복사한다

 - 자식은 그 공간에 새로운 프로그램을 올린다

ex) UNIX 

  1) fork() 시스템 콜이 새로운 프로세스 생성

    - 부모를 그대로 복사

    - 주소 공간 할당

  2) fork 다음에 이어지는 exec() 시스템 콜을 통해 새로운 프로그램을 메모리에 올린다

 

 

프로세스와 관련된 시스템 콜

1. fork() : create a child(copy)

A process is created by the fork() system call.

: creates a new address space that is a duplicate of the caller.

int main() {
   int pid;
   pid = fork();
   if(pid == 0) /* child */
      printf("\n Hello, I am child\n");
   else if (pid > 0) /* parent */
      printf("\n Hello, I am parent\n");
}

fork() 실행시 자식 프로세스가 생겨서 부모 프로세스를 그대로 복제하며

부모 프로세스 Program Counter 도 복제하여, fork() 다음의 if(pid == 0) 라인부터 실행

* 자식 프로세스는 pid = fork(); 이전 라인을 실행하지 못함

 

2. exec() : overlay new image

A process can execute a different program by the exec() system call.

: replaces the memory image of the caller with a new program.

int main() {
   int pid;
   pid = fork();
   if(pid == 0) { /* child */
      printf("\n Hello, I am child\n");
      execIp("echo", "echo", (char *) 0);
   } else if (pid > 0){ /* parent */
         printf("\n Hello, I am parent\n");
   }
   printf("2");
}

fork() 없이 execIp() 만 사용가능

execIp 를 만나는 순간 새로운 프로그램이 기존 프로그램을 덮어쓰게 되며 echo 가 실행되므로

printf("2"); 는 실행 될 수 없음

 

3. wait() : sleep until child is done

프로세스 A가 wait() 시스템 콜을 호출하면

1) 커널은 child가 종료될 때까지 프로세스 A를 sleep 시킨다 (block 상태)

2) child process 가 종료되면 커널은 프로세스 A를 깨운다 (ready 상태)

: 자식이 종료(terminate)될 때까지 부모가 기다리는(wait) 모델

main {
   int childPID;
   childPID = fork();
   if(childPID == 0){
     <code for child process>    
   } else {
      wait();
   }
}

fork 로 자식 프로세스 생성

wait() 으로 부모프로세스가 sleep,

자식 프로세스가 CPU를 얻어서 자식 프로세스의 코드(code for child process)가 실행 된 후(끝난 후)

부모 프로세스가 깨어난다.

 

4. exit() : frees all the resources, notify parent

프로세스의 종료

1. 자발적 종료

   1) 마지막 statement 수행 후 exit() 시스템 콜을 통해

   2) 프로그램에 명시적으로 적어주지 안하도 main 함수가 리턴되는 위치에 컴파일러가 넣어준다

2. 비자발적 종료

   1) 부모 프로세스가 자식 프로세스를 강제로 종료시킨다

     - 자식 프로세스가 한계치를 넘어선 자원을 요청할 때

     - 자식에게 할당된 task가 더 이상 필요하지 않을 때

   2) 키보드로 kill, break 등을 친 경우

   3) 부모가 종료하는 경우

     - 부모 프로세스가 종료하기 전에 자식들이 먼저 종료된다

 

 

프로세스 종료

1. 프로세스가 마지막 명령을 수행한 후 운영체제에게 이를 알려준다(exit)

 - 자식이 부모에게 output data를 보낸다 (via wait)

 - 프로세스의 각종 자원들이 운영체제에게 반납된다

2. 부모 프로세스가 자식의 수행을 종료시킴 (abort)

 1) 자식이 할당 자원의 한계치를 넘어설 때

 2) 자식에게 할당된 테스크가 더 이상 필요하지 않을 때

 3) 부모가 종료(exit)해야하는 경우

   - 운영체제는 부모 프로세스가 종료하는 경우 자식이 더 이상 수행되도록 두지 않는다

   - 딸려있는 모든 자식을 종료시킨 후 부모를 죽이는 단계적인 종료

 

 

프로세스 간 협력

1. 독립적 프로세스(Independent process)

  : 프로세스는 각자의 주소 공간을 가지고 수행되므로 원칙적으로 하나의 프로세스는 다른 프로세스의 수행에 영향을

    미치지 못한다

2. 협력 프로세스(Cooperating process)

  : 프로세스 협력 메커니즘을 통해 하나의 프로세스가 다른 프로세스의 수행에 영향을 미칠 수 있음

3. 프로세스 간 협력 메커니즘(IPC : Interprocess Communication)

1) 메시지를 전달하는 방법

- message passing : 커널을 통해 메시지 전달. 프로세스 사이에 공유 변수를 사용하지 않고 통신하는 시스템

a. Direct Communication : 통신하려는 프로세스의 이름을 명시적으로 표시 

b. Indirect Communication : mailbox(또는 port)를 통해 메시지 간접 전달

 

2) 주소 공간을 공유하는 방법

- shared memory : 서로 다른 프로세스 간에도 일부 주소 공간을 공유하게 하는 shared memory 메커니즘이 있음

thread : thread는 사실상 하나의 프로세스이므로 프로세스 간 협력으로 보기는 어렵지만 동일한 process를 구성하는 thread들 간에는 주소 공간을 공유하므로 협력이 가능

 

 

※ 이화여대 반효경 교수님의 운영체제 강의 정리

반응형

팩토리 패턴

팩토리라는 클래스에 객체 생성을 위임(캡슐화)하여 팩토리 클래스가 객체를 생성하도록 하는 방식.

어떤 클래스의 인스턴스를 생성할지 서브클래스에서 결정하도록 한다는게 팩토리 패턴의 핵심.

분류에 딱히 큰 의미는 없는 듯 하나, 팩토리 메소드 패턴과 추상 팩토리 메소드 패턴으로 나누고 있다.

"구상클래스에 의존하지 않게, 추상화 된 것에 의존하도록 개발" 을 따르는 패턴

 

 

1. 팩토리 메소드 패턴

: 객체 생성을 담당하는 팩토리 메소드 작성하여 객체 생성을 캡슐화

: 객체를 생성하기 위한 인터페이스를 정의하는데, 어떤 클래스의 인스턴스를 만들지는 서브클래스에서 결정한다.

 

[Mouse interface]

1
2
public interface Mouse {
}
cs

[LGMouse.java]

Mouse interface 구현

1
2
3
4
5
public class LGMouse implements Mouse {
    public LGMouse() {
        System.out.println("LG 마우스 생성");
    }
}
cs

[SamsungMouse.java]

Mouse interface 구현

1
2
3
4
5
public class SamsungMouse implements Mouse {
    public SamsungMouse() {
        System.out.println("Samsung 마우스 생성");
    }
}
cs

 

[Factory.java]

객체 생성을 맡아서 처리 하는 팩토리클래스

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Factory {
    public static Mouse createMouse(String type) {
        Mouse mouse = null;
        switch(type) {
            case "LG":
                mouse = new LGMouse();
                break;
            case "SAMSUNG":
                mouse = new SamsungMouse();
                break;
        }
        return mouse;
    }
}
cs

 

[Client]

1
2
3
4
5
public class Client {
    public static void main(String[] args) {
        Factory.createMouse("LG");
    }
}
cs

[결과]

LG 마우스 생성

 

 

2. 추상 팩토리 패턴

: 연관된 서브 클래스를 그룹화할 수 있고 그룹을 자유롭게 교체할 수 있는 패턴

: 인터페이스를 이용하여 서로 연관된, 또는 의존하는 객체를 구상 클래스를 지정하지 않고 생성할 수 있다

: 팩토리 메소드 패턴이 좀 더 캡슐화 되어있는 형태

 

[Mouse interface]

1
2
public interface Mouse {
}
cs

[LGMouse.java]

Mouse interface 구현

1
2
3
4
5
public class LGMouse implements Mouse {
    public LGMouse() {
        System.out.println("LG 마우스 생성");
    }
}
cs

[SamsungMouse.java]

Mouse interface 구현

1
2
3
4
5
public class SamsungMouse implements Mouse {
    public SamsungMouse() {
        System.out.println("SAMSUNG 마우스 생성");
    }
}
cs

 

[Keyboard interface]

1
2
public interface Keyboard {
}
cs

[LGKeyboard.java]

Keyboard interface 구현

1
2
3
4
5
public class LGKeyboard implements Keyboard {
    public LGKeyboard() {
        System.out.println("LG 키보드 생성");
    }
}
cs

[SamsungKeyboard.java]

Keyboard interface 구현

1
2
3
4
5
public class SamsungKeyboard implements Keyboard {
    public SamsungKeyboard() {
        System.out.println("SAMSUNG 키보드 생성");
    }
}
cs

 

[Computer interface]

1
2
3
4
public interface Computer {
    public Keyboard createKeyboard();
    public Mouse createMouse();
}
cs

[ComputerFactory.java]

Computer interface 구현

1
2
3
4
5
6
public class ComputerFactory {
     public void createComputer(Computer computer){
        computer.createKeyboard();
        computer.createMouse();
    }
}
cs

 

[Client.java]

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args) {
        ComputerFactory cf = new ComputerFactory();
        cf.createComputer(new SamsungComputer());
        cf.createComputer(new LGComputer());
    }
}
cs

[결과]

SAMSUNG 컴퓨터 생성
SAMSUNG 키보드 생성
SAMSUNG 마우스 생성
LG 컴퓨터 생성
LG 키보드 생성
LG 마우스 생성

 

참고 :

아래의 포스팅을 많이 참고했습니다. 훌륭한 예제를 보시려면 아래를 참고해주세요..

https://victorydntmd.tistory.com/300

 

 

 

반응형

Thread

프로세스(heavyweight process) 내부에 CPU 수행 단위가 여러개 존재하는 것

CPU를 수행하는 단위

"A thread (or lightweight process is a basic unit of CPU utilication"

 

[Process 정보를 담고 있는 Process Control Block]

[PCB 내에서의 Thread]

data, code 등 메모리 공유가 가능한 자원은 최대한 공유(공유하는 부분은 Task 라 칭함)하며,

CPU 수행과 관련된 Program Counter, registers, Stack 영역은 별도로 가진다. 

 

Thread 사용시 기대 효과

1) 다중 스레드로 구성된 태스크 구조에서는 하나의 서버 스레드가 blocked(waiting) 상태인 동안에도 동일한 태스크 내의 다른 스레드가 실행(running)되어 빠른 처리 가능.

2) 동일한 일을 수행하는 다중 스레드가 협력하여 높은 처리율(throughput)과 성능을 얻을 수 있다

3) 병렬성을 높일 수 있다(CPU가 여러개인 컴퓨터인 경우)

 

Thread 사용시 장점

- Responsiveness " if one thread is blocked, another thread continues

- Resource Sharing : n threads can share binary code, data, resource of the process

- Economy : creating & CPU switching thread rather than a process (overhead)

- Utilization of MP(Multi Processor) Architectures : each thread may be running in parallel on a different processor

 

Thread 구현 방식

- Kernel Threads (supported by kernel)

- User Threads (supported by library)

- Real-time Threads

 

※ 이화여대 반효경 교수님의 운영체제 강의내용 정리

반응형

어댑터 패턴은 실생활에서 사용하는 어댑터와 동일한 역할을 수행한다.

한 클래스의 인터페이스를 클라이언트에서 사용하고자 하는 다른 인터페이스로 변환한다.

 

어댑터 패턴 사용시 라이브러리를 직접 사용하는 것이 아닌, 

라이브러리를 캡슐화한 어댑터를 사용하게 되므로, 소스간 결합도가 약해지는 장점이 있다.

wrapper 와 slf4j(log4j 의 어댑터) 는 어댑터라 볼 수 있다.

 

 

[Adapter Pattern의 Class 다이어그램(참고)]

Client 는 Adapter 구상 클래스를 Target Interface를 통해 사용한다.

Adapter 클래스는 Target Interface를 구현한다.

Adapter 클래스는 Adaptee(새롭게 사용할 구상 클래스) 를 구상 클래스로 사용하며,

Adapter의 Request()는 Adaptee의 SpecificRequest()를 호출한다. (Adaptee를 캡슐화)

Client 는 Adapter 의 Request()를 사용하는 줄 알지만 실제론 Adaptee 의 SpecificRequest()를 사용하게 된다.

 

실제 Adaptor pattern 의 사용 예를 살펴보자.

 

 

1-1. Adapter 패턴을 사용하지 않은 설계

[OldLibraryIF]

1
2
3
public interface OldLibraryIF {
    public void sendPush(String input);
}
cs

 

[OldLibrary]

OldLibrary 인터페이스를 구현하는 클래스

1
2
3
4
5
6
7
public class OldLibrary implements OldLibraryIF {
    
    public void sendPush(String input) {
        System.out.println("send " + input + " using OldLibrary");
    }
    
}
cs

 

[Client]

OldLibrary를 사용하는 클라이언트

1
2
3
4
5
6
public class Client {
    public static void main(String[] args) {
       OldLibraryIF oldLib = new OldLibrary();
       oldLib.sendPush("message");
    }
}
cs

 

[결과]

send message using OldLibrary

위와 같이 모든 구현이 끝나있는 상태에서 기존의 라이브러리였던 OldLibrary 를 제거하고,

아래와 같은 새로운 라이브러리(NewLibrary)를 사용해야 하는 상황이 생긴다면 어떻게 해야할까?

교체대상인 OldLibrary를 사용하는 클라이언트를 일일히 찾아 수정해주어야 한다.

 

1-2. Adapter 패턴을 사용하지 않은 설계에서 OldLibrary를 NewLibrary로 교체

[NewLibraryIF]

1
2
3
4
public interface NewLibraryIF {
    public void sendMsg(String input);
}
 
cs

 

[NewLibrary]

NewLibrary 인터페이스를 구현하는 클래스

1
2
3
4
5
6
7
public class NewLibrary implements NewLibraryIF {
    
    public void sendMsg(String input) {
        System.out.println("send " + input + " using NewLibrary");
    }
    
}
cs

 

[Client]

OldLibrary 대신 NewLibrary를 사용하도록 기존의 Client 를 수정.

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args) {
        NewLibraryIF newLib = new NewLibrary();
        newLib.sendMsg("message");
    }
}
 
cs

 

[결과]

send message using NewLibrary

라이브러리 교체는 쉽게 끝이난 듯 보인다.

하지만 OldLibrary를 사용하는 곳이 수십, 수백곳이라면?!

애초에 어댑터 패턴을 사용했더라면 어땟을까?

 

2-1. Adapter 패턴을 사용한 설계

[Adapter]

OldLibrary를 캡슐화한 Adapter 클래스

1
2
3
4
5
6
7
8
9
10
public class Adapter implements OldLibraryIF{
    
    OldLibraryIF oldLibrary = new OldLibrary();
 
    @Override
    public void sendPush(String input) {
        oldLibrary.sendPush(input);
    }
    
}
cs

 

[Client]

1
2
3
4
5
6
public class Client {
    public static void main(String[] args) {
        OldLibraryIF adapter = new Adapter();
        adapter.sendPush("message");
    }
}
cs

 

[결과]

send message using OldLibrary

Client 에서 OldLibrary를 생성자로 직접 생성하여 사용하는 대신, Adapter 클래스를 사용했다.

이전과 마찬가지로 OldLibrary를 NewLibrary로 교체해보자.

 

2-2. Adapter 패턴을 사용한 설계에서 OldLibrary를 NewLibrary로 교체

[Adapter]

OldLibrary를 멤버변수로 사용하는 대신 NewLibrary를 멤버변수로 사용

1
2
3
4
5
6
7
8
9
10
11
public class Adapter implements OldLibraryIF{
    
    NewLibraryIF newLibrary = new NewLibrary();
 
    @Override
    public void sendPush(String input) {
        newLibrary.sendMsg(input);
    }
    
}
 
cs

 

[Client]

기존의 Client 코드와 동일한 코드를 사용해도 된다.

Adapter 클래스 코드만 수정했을 뿐, Client 코드는 바꾼게 없다.

1
2
3
4
5
6
7
public class Client {
    public static void main(String[] args) {
        OldLibraryIF adapter = new Adapter();
        adapter.sendPush("message");
    }
}
 
cs

 

[결과]

send message using NewLibrary

이와 같이 Adapter 패턴(캡슐화)을 사용하게 되면 라이브러리의 변화가 발생해도 클라이언트를 수정하지 않아도 된다.

도서 <Clean Code> 에도 외부라이브러리를 캡슐화 하여 사용하는 이점에 대해 언급되어있다.

 

 

참고 : Head First Design Patterns

반응형

프로세스

실행중인 프로그램을 프로세스라 한다

 

프로세스의 문맥(context)

특정 시점에서 프로세스가 어디까지 실행됐는지를 파악하기 위해

- CPU 수행 상태를 나타내는 하드웨어 문맥

   Program counter

   각종 register

- 프로세스의 주소 공간

   code, data, stack

- 프로세스 관련 커널 자료 구조

   PCB(Process Control Block)

   Kernel stack

 

 

프로세스의 상태

Running : CPU를 잡고 인스트럭션(instruction)을 수행중인 상태

Ready : CPU를 기다리는 상태(메모리 등 다른 조건을 모두 만족하는 상태)

Blocked (wait, sleep) :

 - CPU를 주어도 당장 instruction을 수행할 수 없는 상태

 - process 자신이 요청한 event(ex: I/O)가 즉시 만족되지 않아 이를 기다리는 상태

  ex) 디스크에서 file을 읽어와야 하는 경우

Suspended (stopped) :

 - 외부적인 이유로 프로세스의 수행이 정지된 상태

 - 프로세스는 통째로 디스크에 swap out 된다

 ex) 사용자가 프로그램을 일시 정지 시킨 경우,

      메모리에 너무 많은 프로세스가 올라와 있을 때(Medium-term Scheduler에 의해)

New : 프로세스가 생성 중인 상태 (보통 프로세스의 상태로 포함되지 않음)

Terminated : 수행이 끝난 상태 (보통 프로세스의 상태로 포함되지 않음)

 

※ Blocked 와 Suspended 의 차이

Running, Ready, Blocked 모두 CPU 관점에서의 상태 분류일 뿐 실제로 프로세스의 작업이 수행이 되고 있는 상태 (CPU에서 프로세스 수행중(Running), I/O에서 프로세스 수행중(Blocked)), 반면 Suspended 는 프로세스 수행 자체가 외부에 의해 정지된 상태

Blocked : Blocked 자신이 요청한 event가 만족되면 Ready

Suspended : 외부에서 resume 해주어야 Active

 

 

프로세스 상태의 흐름

1. CPU에서 하나의 프로세스를 처리 중 (Running)

2. 타이머 인터럽트가 들어오며 프로세스가 Ready Queue 맨 뒤로 가서 줄을 서게 됨 (Ready)

   (실제론 Queue 순서가 아닌, 우선순위에 의해 실행함)

3. 다음 프로세스를 처리

4. I/O 입력이 요구되어 프로세스의 상태가 blocked 로 바뀌고 키보드 I/O Queue 로 이동하여 줄을 서게 됨 (Blocked)

5. 입력이 완료되면 device controller 가 인터럽트를 걸어 CPU 에게 알림

 

 

PCB(Process Control Block)

운영체제가 각 프로세스를 관리하기 위해 프로세스당 유지하는 정보

1) OS가 관리상 사용하는 정보

Process state, Process ID, Priority, Scheduling information

2) CPU 수행 관련 하드웨어 값

Program Counter, registers

3) 메모리 관련

Code, Data, Stack 위치정보

4) 파일 관련

Open File Descriptors

 

 

문맥 교환(Context Switch)

CPU를 한 프로세스에서 다른 프로세스로 넘겨주는 과정

1) CPU를 내어주는 프로세스 상태를 그 프로세스의 PCB에 저장

2) CPU를 새롭게 얻는 프로세스의 상태를 PCB에서 읽어옴

 

a) 프로세스 A --> 인터럽트 or 시스템콜 --> 커널 --> 프로세스 A : 문맥교환 X

b) 프로세스 A --> 인터럽트 or 시스템콜 --> 커널 --> 프로세스 B : 문맥교환 O

a의 경우에도 CPU 수행 정보 등 context 일부를 PCB에 저장해야 하지만 문맥교환을 하는 b의 경우가 오버헤드가 훨씬 더 크다. (b의 경우 cache memory flush 가 수행됨)

 

 

프로세스 큐의 종류

1) Job Queue : 현재 시스템 내에 있는 모든 프로세스의 집합 (Ready Queue + Device Queues)

2) Ready Queue : 현재 메모리 내에 있으면서 CPU를 잡아서 실행되기를 기다리는 프로세스 집합 (Device Queue와 베타관계)

3) Device Queues : I/O device 의 처리를 기다리는 프로세스 집합 (Ready Queue와 베타적 관계)

 


스케쥴러 (Scheduler)

1) Long-term Scheduler (장기 스케쥴러/Job scheduler)

- 시작 프로세스 중 어떤 것들을 ready queue로 보낼지 결정(new -> ready 로 갈 프로세스를 결정)

- 프로세스에 memory를 주는 문제

- 메모리에 올라갈 프로세스 수를 제어 (메모리에 프로그램이 너무 적거나 많으면 효율/성능이 좋지 않음)

- Time sharing system 에서는 보통 장기 스케쥴러가 없다 (무조건 ready 상태로.. (무조건 메모리에 올라감))

 

2) Short-term Scheduler (단기 스케쥴러/CPU scheduler)

- 어떤 프로세스를 다음번에 running 시킬지 결정

- 프로세스에 CPU를 주는 문제

- millisecond 단위로 매우 빨라야 함

 

3) Medium-term Scheduler (중기스케쥴러/Swapper)

- 메모리 여유 공간 마련을 위해 프로세스를 통째로 디스크로 쫓아냄

- 프로세스에게서 memory를 뺏는 문제

 

 

※ 이화여대 반효경 교수님의 운영체제 강의내용 정리

 

반응형

 

1. Mode bit

사용자 프로그램의 잘못된 수행으로 다른 프로그램 및 운영체제에 피해가 가지 않도록 하기 위한 보호 장치

1 사용자모드 : 사용자 프로그램 수행

0 모니터모드 : OS 코드 수행

 

- 보안을 해칠 수 있는 중요한 명령어는 모니터 모드(OS)에서만 수행 가능 == 특권명령

- Interrupt 나 Exception 발생시 하드웨어가 mode bit 을 0으로 바꾼다

- 사용자 프로그램에게 CPU를 넘기기 전에 mode bit 을 1로 바꾼다

 

2. Timer

- 정해진 시간이 흐른 뒤 운영체제에게 제어권이 넘어가도록 interrupt 를 발생시킨다

- 타이머는 매 클럭 틱 마다 1씩 감소

- 타이머 값이 0이 되면 타이머 interrupt 발생 

- CPU를 특정 프로그램이 독점하는 것으로부터 보호

- 타이머는 time sharing을 구현하기 위해 널리 이용된다

- 타이머는 현재 시간을 계산하기 위해서도 사용된다

 

3. Device Controller

3-1. I/O device Controller

- I/O 장치유형을 관리하는 일종의 작은 CPU

- 제어 정보를 위해 control register, status register 를 가진다

- local buffer 를 가진다

- I/O는 실제 device와 local buffer 사이에서 일어난다

- Device controller는 I/O가 끝났을 경우 Interrupt 로 CPU에 그 사실을 알린다

 

Device Driver (장치구동기) : OS 코드 중 각 장치별 처리루틴 (software)

Device Controller (장치제어기) : 각 장치를 통제하는 일종의 작은 CPU (hardware)

 

※ 인터럽트(Interrupt)

인터럽트 당한 시점의 레지스터와 program counter 를 save 한 후 CPU의 제어를 인터럽트 처리 루틴에 넘긴다

- Interrupt (하드웨어 인터럽트) : 하드웨어가 발생시킨 인터럽트

- Trap (소프트웨어 인터럽트) :

  Exception : 프로그램 오류

  System Call : 프로그램이 커널 함수 호출

 

인터럽트 관련 용어

- 인터럽트 벡터

  해당 인터럽트의 처리 루틴 주소를 가지고 있음

  : 함수의 주소 값을 가지고 있는 일종의 테이블

- 인터럽트 처리 루틴 (=Interrupt Service Routine, 인터럽트 핸들러)

  해당 인터럽트를 처리하는 커널 함수

  : 인터럽트마다 처리하는 작업내용이 다르므로 각각의 인터럽트마다 어떤 작업을 수행해야 하는지가 작성되어 있는 코드

 

입출력의 수행

모든 입출력 명령은 특권 명령

사용자 프로그램이 I/O 하는 방법 : 시스템콜(System Call)

1) 인터럽트 라인 세팅

2) CPU는 실행중이던 인스트럭션을 실행한 후 interrupt 확인

3) mode bit 0 으로 바뀜

4) 운영체제에게 CPU 제어권이 넘어감

5) device controller 에게 I/O 데이터 요청

6) CPU는 I/O 를 기다리지 않고, 다른 인스트럭션 실행

7) I/O 입력

8) device controller가 인터럽트 라인 세팅

9) CPU는 실행중이던 인스트럭션을 실행한 후 interrupt 확인

10) mode bit 0으로 바뀜

11) 운영체제에게 CPU 제어권이 넘어감

12) device controller로부터 buffer에 저장된 데이터를 운영체제가 받아옴

13) I/O를 요청했던 인스트럭션의 메모리영역에 buffer 데이터 저장

 

* CPU는 레지스터 중 program counter 가 가르키는 메모리 주소(인스트럭션)을 실행

* program counter 가 가리키는 메모리 주소를 실행하기 전에 interrupt line 을 확인

* mode bit 이 0일 땐 OS 가 CPU 를 가지고 있으므로 모든 인스트럭션 실행이 가능

* mode bit 이 1일 땐 사용자 프로그램이 CPU 를 가지고 있으므로 실행 불가한 인스트럭션이 존재(인터럽트를 걸어 운영체제에게 서비스 요청)

인스트럭션 1개는 4byte

 

입출력 방식

동기식 입출력 : I/O 요청 후 입출력 작업이 완료된 후, 사용자 프로그램에 제어가 넘어감

비동기식 입출력 : I/O 시작된 후 입출력 작업이 끝나기를 기다리지 않고 제어가 사용자 프로그램에 즉시 넘어감

* I/O 완료여부는 interrupt로 알린다.

 

DMA (Direct Memory Access)

- 빠른 입출력 장치를 메모리에 가까운 속도로 처리하기 위해 사용

- CPU의 중재 없이 device controller 가 device의 buffer storage의 내용을 메모리에 block 단위로 직접 전송

- 바이트 단위가 아니라 block 단위로 인터럽트를 발생시킴

* CPU에 인터럽트를 매번 걸지 않아 효율이 증가

 

저장장치 계층구조

* Volatility 휘발성

 

프로그램 실행시 메모리 로드

File System --> virtual memory --(Address transaction 논리메모리 주소를 물리 메모리 주소로 변환)--> physical memory

1) 프로그램 실행시 실행된 각각의 프로그램의 Address space 를 virtual memory 에 생성

2) physical memory 에 virtual memory 의 필요한 일부만 올림

3) 불필요한 경우 Swap area(메모리의 한계로 메모리 연장을 위한 공간으로 사용) 에 저장

 

 

커널 주소 공간의 내용

 

※ 이화여대 반효경 교수님의 운영체제 강의내용 정리 (kocw.net)

반응형

+ Recent posts