//구글콘솔 광고 추가가
파일 시스템(file system)
파일과 디렉터리를 관리하는 운영체제 내의 프로그램. 파일과 디렉터리를 다루어 주는 프로그램.

 

파일과 디렉터리

: 보조기억장치의 데이터 덩어리.

파일 디렉터리
- 보조기억 장치에 저장된 관련 정보의 집합.
- 의미 있고 관련 있는 정보를 모은 논리적 단위.
>>관련있는 정보를 한데 모아놓은 단위 == 파일.

- 윈도우에서는 폴더(folder)
- 옛날엔 : 1단계 디렉터리
- 요즘엔 : 여러계층으로 파일 및 폴더를 관리하는 트리 구조 디렉터리(가장 최상단에 있는 디렉터리를 루트 디렉터리라 부름(/ 슬래쉬로 표현) )
파일을 이루는 정보 디렉터리 경로
파일을 실행하기 위한 정보 + 부가 정보( = 속성, 메타 데이터) 디렉터리를 이용해 파일/ 디렉터리의 위치, 나아가 이름까지 특정 지을 수 있는 정보. 절대 경로와 상대 경로.
같은 디렉터리에는 동일한 이름의 파일이 존재할 수 없지만, 서로 다른 디렉터리에는 동일한 이름의 파일이 존재할 수 있음.
파일의 속성 정보 경로의 종류
속성 이름 의미 절대 경로 : 루트 디렉터리에서 자기 자신까지 이르는 고유한 경로(e.g.> /home/nomatter-me/a.cpp)
>> 루트 디렉터리 부터 시작하는 경로.
유형 운영체제가 인지하는 파일의 종류.
확장자로서 특정 지을 수 있음.(cpp,xml등)
상대 경로: 현재 디렉터리에서 자기 자신까지 이르는 경로
(e.g> 현재 디렉터리 경로가 /home일 경우 guest/d.jpg)
>> 현재 디렉터리부터 시작하는 경로.
크기 파일의 현재 크기와 허용 가능한 최대 크기. 디렉터리 연산을 위한 시스템 호출
보호 어떤 사용자가 해당 파일을 읽고, 쓰고, 실행할 수 있는 지를 나타냄. 1. 디렉터리 생성 2. 디렉터리 삭제 3. 디렉터리 열기
4. 디렉터리 닫기 5. 디렉터리 읽기 등
생성 날짜 파일이 생성된 날짜. 사실, 많은 운영체제에서는 디렉터리를 그저 "특별한 형태의 파일"로 간주한다!
즉, 디렉터리는 그저 "포함된 정보가 조금 특별한 파일".
--------------------------------------------------------------------------------
파일의 내부에는 파일과 관련된 정보들이 있다면, 디렉터리의 내부에는 해당 디렉터리에 담겨있는 대상과 관련된 정보들이 담겨있다. >> 이 정보는 보통 테이블(표) 형태로 구성.

마지막 접근 날짜 파일에 마지막으로 접근한 날짜.
마지막 수정 날짜 파일이 마지막으로 수정된 날짜.
생성자 파일을 생성한 사용자.
소유자 파일을 소유한 사용자.
위치 파일의 보조기억장치상의 현재 위치.
파일 연산을 위한 시스템 호출 디렉터리 엔트리
1. 파일 생성 2. 파일 삭제 3. 파일 열기
4. 파일 닫기 5. 파일 읽기 6. 파일 쓰기 등
각 엔트리(행)에 담기는 정보 - 디렉터리에 포함된 대상의 이름, 그 대상이 보조기억장치 내에 저장된 위치(를 유추할 수 있는 정보), 가끔 파일 속성을 명시하는 경우도 있음.

 

파일 시스템이 파일과 디렉터리를 보조기억장치에 할당하고 접근하는 방법과
대표적인 파일 시스템의 종류(FAT 파일시스템, 유닉스 파일시스템) 대해 공부해 보자.

 

파티셔닝과 포매팅

- 파티셔닝과 포매팅을 해야지 파일시스템을 통해 파일과 디렉터리에 접근 가능 

파티셔닝 포매팅
- 저장 장치의 논리적인 영역을 구획하는 작업.
  이 떄 구획된 각각의 구역을 파티션이라 함.
- 파일 시스템을 설정. (파일 시스템은 포매팅할 때 결정 됨.)
- 어떤 방식으로 파일을 관리할 지 결정, 새로운 데이터를 쓸 준비를 하는 작업
- 파일 시스템에는 여러 종류가 있고, 파티션마다 다른 파일 시스템을 설정할 수도 있다.
포매팅까지 완료하여 파일 시스템을 설정했다면 이제 파일과 디렉터리 생성이 가능해진다. 
< 파일 할당 방법 >
- 포매팅까지 끝난 하드 디스크에 파일을 저장하기.
- 운영체제는 파일/ 디렉터리를 블록 단위로 읽고 쓴다.
    >> 즉, 하나의 파일이 보조기억장치에 저장될 때에는 여러 블록에 걸쳐 저장된다. (하드 디스크의 가장 작은 저장 단위는 섹터이지만 보통 블록 단위로 읽고 쓴다.)

- 파일을 보조기억장치에 할당하는 두 가지 방법 : 연속 할당, 불연속 할당(오늘날 사용되는 방식)

연속 할당 불연속 할당
: 이름 그대로 보조기억장치 내 연속적인 블록에 파일 할당.
> 파일이 저장 장치 내에서 연속적인 공간을 차지하도록 블록을 할당하는 방법.
연결 할당
: 각 블록의 일부에 다음 블록의 주소를 저장하여 각 블록이 다음 블록을 가리키는 형태로 할당.(더이상 불러들일 주소가 없을 경우 다음 블록의 주소에  -1 삽입)
>>파일을 이루는 데이터 블록을 연결 리스트로 관리.
>>불연속 할당의 일종 : 파일이 여러 블록에 흩어져 저장되어도 무방. 

디렉터리 엔트리 : 파일 이름 & 첫번째 블록 주소 & 블록 단위의 길이
색인 할당
: 파일의 모든 블록 주소를 색인 블록이라는 하나의 블록에 모아 관리하는 방식.
>> 파일내 임의의 위치에 접근하기 용이

디렉터리 엔트리 : 파일 이름 & 색인 블록 주소 
연속된 파일에 접근하기 위해 파일의 첫 번째 블록 주소와 블록 단위의 길이만 알면 된다.

디렉터리 엔트리 : 파일 이름 & 첫 번째 블록 주소 & 블록 단위 길이 명시.
연속 할당의 부작용 연결 할당의 단점  
: 구현이 단순하지만 외부 단편화를 야기할 수 있다.
ex> 연속할당을 해둔 파일 중 중간 파일들을 삭제했을때 삭제한 파일의 블록수보다 더 큰 파일을 할당 할수 없음. 
파일 A의 블록 개수 4개. 파일 B의 블록 개수 5개.
파일 C의 블록 개수 2개. 파일 D의 블록 개수 6개.
파일 E의 블록 개수 3개.
파일 B와 D를 삭제하면 잔여 블록의 개수는 삭제한 파일들의 블록의 개수 11개(5개 + 6개)가 되는데 추가로 넣을 파일 F의 블록 개수가 10개라 하더라도 빈 블록 위치가 다르기때문에 파일을 할당시키지 못함.
1. 반드시 첫번째 블록부터 하나씩 읽어 들여야 한다. == 파일에 임의의 위치에  접근하는 속도가 느림.
2. 오류 발생 시 해당 블록 이후 블록은 접근이 어렵다.

 

FAT 파일 시스템
: 연결 할당 기반 파일 시스템, 연결 할당의 단점을 보완  오늘날 많이 사용하는 파일 시스템

- 각 블록에 포함된 다음 블록 주소를 한데 모아 테이블(FAT; File Allocation Table)로 관리

>> FAT가 메모리에 캐시 될 경우 느린 임의 접근 속도 개선 가능 

디렉터리 엔트리  파일 이름 & 확장자 & 속성 & 예약 영역 & 생성 시간 & 마지막 접근 시간 & 마지막 수정 시간 & 시작 블록 & 파일 크기
유닉스 파일 시스템
: 색인 할당 기반 파일 시스템. 색인 블록 == i-node (파일 속성 정보와 15개의 블록 주소 저장 가능)

- 사실상 i-node가 파일 시스템의 핵심

디렉터리 앤트리 i-node 번호 & 파일 이름
15개 이상의 블록 주소가 있다면? 유닉스 파일 시스템이 큰 파일들을 어떻게 관리하는지 확인해 보자.
1. 블록 주소 중 12개에는 직접 블록 주소 저장. (직접블록 : 파일 데이터가 저장된 블록)
2. 1번으로 충분하지 않다면 13번째 주소에 단일 간접 블록 주소 저장. (단일 간접 블록 : 파일 데이터를 저장한 블록 주소가 저장된 블록)
3. 2번으로 충분하지 않다면 14번째 주소에 이중 간접 블록 주소 저장. (이중 간접 블록 : 단일 간접 블록들의 주소를 저장하는 블록)
4. 3번으로 충분하지 않다면 15번째 주소에 삼중 간접 블록 주소 저장. (삼중 간접 블록 : 이중 간접 블록들의 주소를 저장하는 블록)
>> 이렇게 하면 못 담을 데이터가 없음

 

728x90
페이징의 이점은 외부단편화만 있는 것이 아니다!
쓰기 시 복사도 있다!
쓰기 시 복사( 프로세스 간에 페이지 공유할 수 있다의 대표적 예시)
 - 이론적인 fork()시스템 호출 :
>> 프로세스는 기본적으로 자원을 공유하지 않는다. >> 부모 프로세스가 적재된 별도의 공간이 자식 프로세스가 통째로 복제(부모 프로세스 복사본)되어 적재.
>> 단점: 프로세스 생성 시간 지연, 메모리 낭비(동일한 내용이 메모리에 중복해서 적재되기 때문)

이를 해결하는 방법쓰기시 복사 방법.
- 쓰기시 복사: 
>> 부모 프로세스와 동일한 자식 프로세스가 복제되어 생성되면 자식 프로세스는 부모 프로세스와 동일한 프레임을 가리킴(쓰기 작업없다면 이 상태 유지). 
>> 프로세스는 기본적으로 자원을 공유하지 않는다. 라고 말했듯이 부모 프로세스 / 자식 프로세스 둘 중 하나가 페이지에 쓰기 작업 수행 시 해당 페이지는 별도의 공간으로 복제됨.
>> 장점 : 프로세스 생성 시간 절약, 메모리 절약(중복해서 메모리를 저장하지 않기 때문.) 
프로세스 테이블의 크기는 생각보다 작지 않다.
프로세스를 이루는 모든 페이지 테이블 엔트리를 메모리에 두는 것은 큰 낭비.
프로세스를 이루는 모든 페이지 테이블 엔트리를 항상 메모리에 유지하지 않을 방법이 바로 계층적 페이징

 

계층적 페이징 (== 다단계 페이지 테이블)

- 페이지 테이블을 페이징하여 여러 단계의 페이지를 두는 방식. 페이지 테이블을 여러 페이지로 쪼개고 이 페이지를 가리키는 페이지 테이블(Outer페이지 테이블)을 두는 방식.

- 모든 페이지 테이블을 항상 메모리에 있을 필요가 없어짐.

>> CPU와 가장 가까이 위치한 페이지 테이블(Outer 페이지 테이블)은 항상 메모리에 유지, 필요한 페이지들만 메모리에 유지하면 됨.

- 계층적 페이징을 이용하는 환경에서의 논리 주소  

논리 주소의 구조
바깥 페이지 번호 안쪽 페이지 번호 변위
1. 바깥 페이지 번호를 통해 페이지 테이블의 페이지를 찾기.
2. 페이지 테이블의 페이지를 통해 프레임 번호를 찾고 변위를 더함으로서 물리 주소 얻기.

 

페이징을 통해 물리 메모리보다 큰 프로세스를 실행할 수 있지만,
그럼에도 물리 메모리의 크기는 한정되어 있다.
운영체제는 기존에 적재된 불필요한 페이지를 선별해 보조기억장치로 내보내고(=페이지 교체 알고리즘으로 해결) 프로세스들에게 적절한 수의 프레임을 할당해야 한다. 
요구 페이징

- 처음부터 모든 페이지를 적재하지 않고 필요한 페이지만을 메모리에 적재하는 기법. 요구되는 페이지만 적재하는 기법.

요구페이징이 실행되는 기본적인 양상
1. CPU가 특정 페이지에 접근하는 명령어를 실행한다.
2. 해당 페이지가 현재 메모리에 있을 경우(유효비트가 1일 경우) CPU는 페이지가 적재된 프레임에 접근한다.
3. 해당 페이지가 현재 메모리에 없을 경우(유효비트가 0일 경우) 페이지 폴트가 발생한다.
4. 페이지 폴트 처리 루틴은 해당 페이지를 메모리로 적재하고 유효 비트를 1로 설정한다.
5. 다시 1번을 수행한다.

요구 페이징 시스템이 안정적으로 작동하려면 해결해야 할 2가지 문제.
1. 페이지 교체.
2. 프레임 할당. 

>> 요구 페이징 기법으로 페이지들을 적재하다 보면 언젠간 메모리가 가득 차게 됨.
당장 실행에 필요한 페이지를 적재하려면 적재된 페이지를 보조기억장치로 내보내야 하는데, 이때 어떤 페이지를 내보낼지 결정하는 방법(알고리즘)이 바로 페이지 교체 알고리즘.
페이지 교체 알고리즘
>> 여러가지가 있지만 그중 제일 중요하게 생각해야 하는 게 바로 페이지 폴트가 적은 페이지 교체 알고리즘!!!

- 페이지 폴트가 발생하면 보조기억 장치에 접근해야 해서 성능이 저하되기 때문이다.

페이지 폴트 횟수는 어떻게 알수 있을까?
- 페이지 참조열(page reference string) : CPU가 참조하는 페이지들 중 연속된 페이지를 생략한 페이지열.
CPU가 논리 주소를 통해 특정 주소를 요구하는데 메인 메모리에 올라와 있는 주소들은 페이지의 단위로 가져오기 때문에 페이지 번호가 연속되어 나타나게 되면 페이지 결함이 일어나지 않음. 따라서 CPU의 주소 요구에 따라 페이지 결함이 일어나지 않는 부분은 생략하여 표시하는 기법을 페이지 참조열이라 한다. 
여러 페이지 교체 알고리즘들 중 세가지
FIFO 페이지 교체 알고리즘 - 가장 단순한 방식.
- 메모리에 가장 먼저 올라온 페이지부터 내쫓는 방식.
- "오래 머물렀다면 나가."
<단점>
- 프로그램 실행 초기에 잠깐 실행될 페이지가 있을 순 있겠지만, 프로그램 실행 내내 사용될 페이지가 있을 수 있는데 이런 페이지의 경우엔 먼저 적재되어 있다고 내쫓아선 안됨.
<보완책>
- 2차 기회(second-change) 페이지 교체 알고리즘(참조비트를 통해 내쫓을지 말지 한번의 기회를 더 줌)
 * 참조비트 1 : CPU가 한 번 참조한 적이 있는 페이지.>> 내보내지 않고, 적재된 시간을 현재 시간으로 설정,맨끝으로 보냄.(가장 최근에 적재된 페이지로 간주)
즉, 한번더 기회를 줌.(참조비트 0으로 초기화 후 적재 시간을 현재 시간으로 설정.)
 * 참조비트 0 : CPU가 참조한 적이 없는 페이지.  >> 내쫓음.
최적 페이지 교체 알고리즘 - CPU에 의해 참조되는 횟수를 고려.
- 메모리에 오래 남아야 할 페이지는 자주 사용될 페이지.
- 메모리에 없어도 될 페이지는 오랫동안 사용되지 않을 페이지.
- 앞으로의 사용 빈도가 가장 낮은 페이지를 교체하는 알고리즘. 
- 가장 낮은 페이지 폴트율을 보장하는 페이지 교체 알고리즘.
- BUT, 실제 구현이 어렵다.

-"앞으로 오랫동안 사용되지 않을 페이지? 어떻게 예측하지??"
- 다른 페이지 교체 알고리즘 성능을 평가하기 위한 척도로서 하한선으로 간주. 
LRU(Least- Recently-Used)
페이지 교체 알고리즘
- 최적 페이지 교체 알고리즘: 가장 오래 사용되지 페이지 교체 방식.
- LRU 페이지 교체 알고리즘: 가장 오래 사용되지 페이지 교체 방식.
   - "최근에 사용되지 않은 페이지는 앞으로도 사용되지 않지 않을까??"

 

 

페이지 폴트가 자주 발생하는 이유는
나쁜 페이지 교체 알고리즘을 사용했거나, 프로세스가 사용할 수 있는 프레임 자체가 적어서!! 

 

스래싱과 프레임 할당
< 스레싱 >
- 프로세스가 실행되는 시간보다 페이징에 더 많은 시간을 소요하여 성능(CPU이용률)이 저하되는 문제를 말함.
- 동시 실행되는 프로세스의 수를 늘린다고 CPU 이용률이 높아지는 것은 아님.  
- 근본적인 이유 :
>> 각 프로세스가 필요로 하는 최소한의 프레임 수가 보장되지 않았기 때문.
>> 각 프로세스가 필요로 하는 최소한의 프레임 수를 파악하고, 프로세스들에게 적절한 프레임을 할당해줘야 한다.

< 프로세스의 크기나, 물리 메모리의 크기를 통한 프레임 할당 방식 2가지 >
1. 균등 할당(equal allocation) :
가장 단순한 할당 방식. 모든 프로세스들에게 균등하게 프레임을 할당하는 방식.
>> 권장은 ㄴㄴ. 상대적으로 크기가 큰 프로그램(게임)과 작은 프로그램(메모장)에게 똑같은 프레임을 할당한다 생각해 봐.
2. 비례 할당(proportional allocation) :
프로세스의 크기를 고려. 프로세스 크기에 비례하는 프레임 할당.
>> 완벽한 방식은 ㄴㄴ. 크기가 큰 프로세스인데 막상 실행해 보니 많은 프레임을 필요로 하지않거나, 크기가 작은 프로세스인데 막상 실행해보니 많은 프레임이 필요한 경우가 있기 때문. 결국 프로세스가 필요로 하는 프레임 수는 실행해 봐야 안다.
** 균등할당과 비례할당은 프로세스의 실행과정은 고려하지 않고 단순히 프로세스의 크기나, 물리 메모리의 크기만을 고려한 방식이라 정적 할당 방식이라 부름.

< 프로세스를 실행하는 과정에서 프레임을 결정하는 방식 2가지 >
1. 작업 집합 모델 사용 방식 : 
프로세스가 실행하는 과정에서 배분할 프레임 결정. 스레싱이 발생하는 이유는 빈번한 페이지 교체 때문이기에 CPU가 특정 시간 동안 주로 참조한 페이지 개수만큼만 프레임을 할당하면 된다. 
"프로세스가 일정 기간 동안 참조한 페이지 집합"을 기억하여 빈번한 페이지 교체를 방지하는 방식이 작업집합 모델 기반의 프레임 할당 방식. 
** 작업 집합이란 "실행 중인 프로세스가 일정 시간 동안 참조한 페이지의 집합".
- 작업집합을 구하려면??
> 1. 프로세스가 참조한 페이지
> 2. 시간 간격이 필요함.
2. 페이지 폴트 빈도 기반의 프레임 할당 방식 :
프로세스가 실행하는 과정에서 배분할 프레임 결정.
- 두 개의 가정에서 생겨난 아이디어 
1. 페이지 폴트율이 너무 높으면 그 프로세스는 너무 적은 프레임을 갖고 있다.
2. 페이지 폴트율이 너무 낮으면 그 프로세스가 너무 많은 프레임을 갖고 있다.
페이지 폴트율에 상한선과 하한선을 정하고, 그 내부 범위 안에서만 프레임을 할당하는 방식.
** 작업 집합 모델 사용방식과 페이지 폴트 빈도 기반의 프레임 할당 방식은 프로세스가 실행하는 과정을 통해서( == 관찰함으로써) 프레임을 할당하는 방식이라 동적할당 방식이라 부름. 

 

728x90
연속 메모리 할당 : 프로세스에 연속적인 메모리 공간을 할당.

 

운영체제가 메모리를 관리하는 기본적인 기능 중 하나, 스와핑
: 현재 사용되지 않는 프로세스들을 보조기억장치의 일부 영역으로 쫓아내고 그렇게 생긴 빈 공간에 당장 사용할 새 프로세스 적재

스와핑

- 이점: 프로세스들이 요구하는 메모리 공간 크기 > 실제 메모리 크기
- 스왑영역 크기 확인하기 : free, top명령어로 확인 가능
연속 메모리 할당

- 프로세스는 메모리의 빈 공간에 할당되어야 한다. 빈 공간이 여러개 있다면?

어떤 빈 공간에 할당 될지에 따라 최초 적합, 최적 적합, 최악 적합의 세 가지 방식이 있다.

최초 적합(first-fit) 최적 적합(best-fit) 최악 적합(worst-fit)
- 운영체제가 메모리 내의 빈 공간을 순서대로 검색하다 적재할 수 있는 공간을 발견하면 그 공간에 프로세스를 배치하는 방식.
- (빈 공간)검색 최소화, 빠른 할당.
-운영체제가 빈 공간을 모두 검색해본 뒤, 적재 가능한 가장 작은 공간에 할당. - 운영체제가 빈 공간을 모두 검색해본뒤, 적재 가능한 가장 큰 공간에 할당.
**연속 메모리 할당의 두가지 문제점
사실, 프로세스를 연속적으로 메모리에 할당하는 방식은 메모리를 효율적으로 사용하는 방법이 아님.
>> 1. 외부 단편화(external fragmentation)이라는 잠재적 문제가 발생하기 때문.
>> 2. 물리 메모리보다 큰 프로세스 실행 불가.

- 외부 단편화란?
: 프로세스를 할당하기 어려울 만큼 작은 메모리 공간들로 인해 메모리가 낭비되는 현상.  남아있는 총 메모리 공간이 요청한 메모리 공간보다 크지만, 남아있는 공간이 연속적이지 않아 발생하는 현상.
>>해결 방법:
1. 메모리 압축 방식(conpaction) : 여기 저기 흩어져 있는 빈 공간들을 하나로 모으는 방식. 프로세스를 적당히 재배치시켜 흩어져 있는 작은 빈 공간들을 하나의 큰 빈 공간으로 만드는 방법.
2. 가상메모리 관기법 : 실행하고자 하는 프로그램을 일부만 메모리에 적재하여 실제 물리 메모리 크기보다 더 큰 프로세스를 실행할 수 있게 하는 기술. 페이징( 현재 대부분의 운영체제가 사용하는 방법.)과 세그멘테이션이 있음.
외부 단편화가 발생했던 근본적인 문제는
각기 다른 크기의 프로세스가 메모리에 연속적으로 할당되었기 때문. 
페이징이란?
: 프로세스를 일정 크기로 자르고, 이를 메모리에 불연속적으로 할당함으로써 외부 단편화를 해결.
페이징(paging)
: 프로세스의 논리 주소 공간을 페이지(page)라는 일정 단위로 자르고,
 메모리의 물리 주소 공간을 프레임(frame)이라는 페이지와 동일한 일정한 단위로 자른 뒤
 페이지를 프레임에 할당하는 가상 메모리 관리 기법. 

- 페이징에서의 스와핑

  - 프로세스 단위의 스왑 인, 스왑 아웃이 아닌 페이지 단위의 스왑 인(페이지 인), 스왑 아웃(페이지 아웃)
  - 메모리에 적재될 필요가 없는 페이지들은 보조기억장치로 스왑 아웃.
  - 실행에 필요한 페이지들은 메모리로 스왑 인.
>> 프로세스를 실행하기 위해 모든 페이지가 적재될 필요 없다.
>> 달리 말해 물리 메모리보다 큰 프로세스도 실행될 수 있다. 

- 페이지 테이블
: (실제 메모리 내의 주소인) 물리 주소에 불연속적으로 배치되더라도,
(CPU가 바라보는 주소인) 논리 주소에는 연속적으로 배치되도록 하는 방법.
- 페이지 번호와 프레임 번호를 짝지어 주는 일종의 이정표.
- 프로세스마다 페이지 테이블이 있다.
- 물리적으로는 분산되어 저장되어 있더라도 CPU 입장에서 바라본 논리 주소는 연속적으로 보임.
- CPU는 그저 논리 주소를 순차적으로 실행 하면 될 뿐임. 
- 외부 단편화를 해결하는 대신 내부 단편화라는 또 다른 부작용이 생김. 그래도 외부 단편화보다 메모리 낭비가 작음.

* 내부 단편화 : 하나의 페이지 크기보다 프로세스 크기가 작은 크기로 발생하는 메모리 낭비 문제. 주기억장치 내 사용자영역이 실행 프로그램보다 커서 프로그램의 사용 공간을 할당 후 사용되지 않고 남게 되는 현상.
(100MB의 메모리에 80MB의 크기의 프로세스를 올리게 되면 20MB의 내부 단편화가 발생.)

 

PTBR (프로세스 테이블 베이스 레지스터)
: 각 프로세스의 페이지 테이블이 적재된 주소를 가리킨다.
프로세스마다 페이지 테이블이 있고, 각 페이지 테이블은 CPU내의 프로세스 테이블 베이스 레지스터(PTBR)가 가리킨다.

PTBR

페이지 테이블이 전부다 메모리에 저장되어 있으면 부작용이 발생함. 
>> 메모리 접근 시간이 두배로 늘어남. (페이지 테이블 참조하기 위해 1번, 페이지 참조하기 위해 1번) 

이를 위해 사용하는 방식인 TLB
: CPU곁에 페이지 테이블의 캐시 메모리 이용. 페이지 테이블의 일부를 가져와 저장.
- CPU가 접근하려는 논리 주소가 TLB에 있다면? : TLB 히트 (메모리 접근 1번)
- CPU가 접근하려는 논리 주소가 TLB에 없다면? : TLB 미스 (메모리 접근 2번)
페이징에서의 주소 변환

특정 주소에 접근하고자 한다면 어떤 정보가 필요할까?

 - 이떤 페이지/ 프레임에 접근하고 싶은지, 접근하려는 주소가 그 페이지 혹은 프레임으로부터 얼마나 떨어져 있는지에 대해 알아야 됨. (ex> 프로세스 A의 페이지 2에서 10만큼 떨어진 주소에 접근할래!)

페이지 시스템에서의 < 페이지 번호(page number)와 변위(offset) >로 이루어진 논리 주소는  >> 페이지 테이블을 통해 >> < 프레임 번호, 변위 > 로 이루어진 물리주소로 변환된다.
이 두가지의 변위는 같다.
페이지 테이블 엔트리 (PTE)
: 페이지 테이블의 각각의 행 .

현재까지 설명한 PTE: 페이지 번호, 프레임 번호. 이외에 담기는 정보는? 운영체제에 따라 달라지지만 알아보자.

1. 유효 비트 : 현재 해당 페이지에 접근 가능한지 여부. 현재 페이지가 스왑영역으로 쫓겨났는지 아닌지, 현재 페이지가 메모리에 적재돼있는지, 아닌지를 나타냄. 

- 유효 비트가 0인 페이지에 접근하려고 하면? 페이지 폴트(page fault)라는 인터럽트 발생.

** 페이지 폴트(page fault)라는 인터럽트
1. CPU는 기존의 작업 내역을 백업
2. 페이지 폴트 처리 루틴 실행
3. 페이지 처리 루틴은 원하는 페이지를 메모리로 가져온 뒤 유효 비트를 1로 변경.
4. 페이지 폴트를 처리했다면 이제 CPU는 해당 페이지에 접근할 수 있게 됨.

2. 보호 비트 : 페이지 보호 기능을 위해 존재하는 비트. 보호 비트는 페이지에 접근할 권한을 제한하여 페이지를 보호하는 비트.

3. 참조 비트 : CPU가 이 페이지에 한 번이라도 접근한 적이 있는지 여부. 

4. 수정 비트( = dirty bit) : CPU가 이 페이지에 한번이라도 데이터를 쓴 적이 있는지 여부.(수정이 됐으면 1, 안됬으면 0)

수정비트의 존재 이유는? 수정된 페이지는 스왑 아웃될 때 보조기억장치에도 쓰기 작업을 거쳐야(반영해) 하기 때문에. 

728x90
교착 상태란?

일어나지 않을 사건을 기다리며 진행이 멈춰 버리는 현상.

교착 상태를 해결하기 위해서는?
  1. 교착 상태가 발생했을 때의 상황을 정확하게 표현해 보기
  2. 교착 상태가 일어나는 근본적인 이유 이해하기.
1. 교착 상태가 발생했을 때의 상황을 정확하게 표현해 보기 - 그래프를 그려보자

자원 할당 그래프
: 교착 상태가 발생했을 때의 상황을 표현하기 위한 그래프
>>교착 상태 발생 조건 파악 가능
- 어떤 프로세스가 어떤 자원을 할당받아 사용 중인지 확인 가능.
- 어떤 프로세스가 어떤 자원을 기다리고 있는지 확인 가능.

교착상태가 일어난 그래프의 특징은 자원 할당 그래프가 원의 형태를 띄고 있다.
2. 교착 상태가 일어나는 근본적인 이유 이해하기.

교착 상태가 발생할 4가지 조건

1. 상호 배제 : 한 프로세스가 사용하는 자원을 다른 프로세스가 사용할 수 없는 상태
2. 점유와 대기 : 자원을 할당받은 상태에서 다른 자원을 할당받기를 기다리는 상태
3. 비선점 : 어떤 프로세스도 다른 프로세스의 자원을 강제로 빼앗지 못하는 상태
4. 원형 대기 : 프로세스들이 원의 형태로 자원을 대기하는 상태

위 네 가지 조건 중 하나라도 만족하지 않으면 교착 상태가 발생하지 않음.
위 네가지 조건을 모두 만족하면 교착 상태가 발생할 수 있음.
교착 상태 해결 방법 4가지.
예방, 회피, 검출 후 회복.

교착 상태 예방 애초에 교착 상태가 발생하지 않도록 교착 상태 발생 조건(상호배제, 점유와 대기, 비선점, 원형 대기)중 하나를 없애버리기
>> 교착 상태가 발생하지 않음은 보장할 수 있으나 부작용이 따르는 방식.
상호배제 없애기 모든 자원을 공유 가능하게 만들기 >> 이론적으론 가능하지만 현실적으로 ㄴㄴ
점유와 대기 없애기 특정 프로세스에 자원을 모두 할당하거나, 아예 할당하지 않는 방식으로 배분
>> 자원의 활용률을 낮출 수 있는 방식이라 부작용이 있음.
비선점 조건 없애기 선점이 가능한 자원(e.g. CPU)에 한해 효과적
>> 모든 자원이 선점 가능한 것은 아니다.
원형 대기 조건을 없애기 자원에 번호를 붙이고 오름차순으로 할당하면 원형 대기는 발생하지 않음
>> 자원에 번호를 붙이는 것은 어려운 작업, 어떤 자원에 어떤 번호를 붙이느냐에 따라 활용률이 달라짐.
교착 상태 회피 - 교착 상태를 무분별한 자원 할당으로 인해 발생했다고 간주
- 교착 상태가 발생하지 않을 만큼 조심히 할당하기
- 배분할 수 있는 자원의 양을 고려하여 교착 상태가 발생하지 않을 만큼만 자원 배분
안전 순서열 교착 상태 없이 안전하게 프로세스들에 자원을 할당 할 수 있는 순서
안전 상태 교착 상태 없이 모든 프로세스가 자원을 할당 받고 종료될 수 있는 상태
- 안전 순서열이 있는 상태
불안전 상태 교착 상태가 발생할 수도 있는 상태
- 안전 순서열이 없는 상태
- 안전 상태에서 안전 상태로 움직이는 경우에만 자원을 할당하는 방식
- 항시 안전 상태를 유지하도록 자원을 할당하는 방식
- c.f. 은행원 알고리즘 

교착 상태 검출 후 회복 - 교착 상태의 발생을 인정하고 사후에 조치하는 방식
- 프로세스가 자원을 요구하면 일단 할당, 교착 상태가 검출되면 회복
- 선점을 통한 회복, 프로세스 강제 종료를 통한 회복 
선점을 통한 회복 - 교착 상태가 해결될 때까지 한 프로세스씩 자원을 몰아주는 방식
프로세스 강제 종료를 통한 회복 - 교착 상태에 놓인 프로세스 모두 강제종료(>> 작업 내역을 잃을 위험)
- 교착 상태가 해결될 때까지 한 프로세스씩 강제종료(>> 오버헤드)

 

++교착 상태 무시 ( == 타조 알고리즘) : 문제가 발생했을 때 무시해 버리는 방법.

728x90
동시 다발적으로 실행되는 프로세스들은 서로 협력하며 영향을 주고받는다.
이 과정에서 자원의 일관성을 보장해야 한다.  >> 즉, 프로세스들의 동기화를 고려해야 한다.

공동의 목적을 위해 동시에 수행되는 프로세스들은 아무렇게나 마구 실행해도 괜찮을까?

>> ㄴㄴ 올바른 수행을 위해 프로세스들은 동기화되어야 함.

프로세스의 동기화란?
프로세스들의 수행 시기를 맞추는 것
크게 두 가지를 의미
- 실행 순서 제어 : 프로세스를 올바른 순서대로 실행하기
- 상호 배제 : 동시에 접근해서는 안 되는 자원에 하나의 프로세스만 접근하게 하기 
* 실행의 문맥을 갖는 모든 대상은 동기화 대상이기에 스레드도 동기화 대상. 
실행 순서 제어를 위한 동기화 : reader writer problem 상호배제를 위한 동기화 :
Bank account problem , Producer & Consumer problem
(레이스 컨디션(race condition)의 사례)
Writer: Book.txt 파일에 값을 저장하는 프로세스
Reader: Book.txt파일에 저장된 값을 읽어들이는 프로세스
----------------------------------------------------------------------------
Reader와 Writer프로세스는 무작정 아무렇게나 실행되어선 안된다. 실행의 순서가 있기 때문
Reader 프로세스는 "Book.txt"안에 값이 존재한다"는 특정 조건이 만족되어야만 실행 가능
공유가 불가능한 자원의 동시 사용을 피하기 위한 동기화
== 한번에 하나의 프로세스만 접근해야 하는 자원에 동시 접근을 피하기 위한 동기화
---------------------------------------------------------------------------------------
현재 계좌에 잔액 : 10만원
프로세스 A는 현재 잔액에 2만원을 추가하는 프로세스
프로세스 B는 현재 잔액에 5만원을 추가하는 프로세스 
프로세스의 실행이 끝나고 다음 프로세스가 실행되어야 잔액의 오류가 없음.
--------------------------------------------------------------------------------------
물건을 계속해서 1씩 생산하는 생산자(producer, 프로세스 혹은 스레드)
물건을 계속해서 1씩 소비하는 소비자(consumer, 프로세스 혹은 스레드)
"총합" 변수 공유, 이 상태에서 생산자를 100,000번, 소비자를 100,000번 실행했을때 총합은? 예상과 다르게 결과 값 나옴.
>> 동기화가 되지 않았기 때문에 발생하는 문제.
동시에 접근해서는 안되는 자원(총합)에 동시에 접근해서 발생한 문제.

 

공유 자원과 임계구역

공유자원 :  여러 프로세스 혹은 스레드가 공유하는 자원 (전역변수, 파일, 입출력장치, 보조기억장치 ...)

임계 구역 : 공유 자원에 접근하는 코드 중 동시에 실행하면 문제가 발생하는 코드 영역

임계 구역에 진입하고자 하면 진입한 프로세스 이외에는 대기해야 한다.

임계 구역에 동시에 접근하면 자원의 일관성이 깨질 수 있다. 이를 레이스 컨디션(race condition)이라 한다.

 

운영체제가 임계구역 문제를 해결하는 세 가지 원칙 (상호배제를 위한 동기화를 위한 세가지 원칙)
1. 상호 배제(mutual exclusion) :
 한 프로세스가 임계 구역에 진입했다면 다른 프로세스는 들어올 수 없다.

2. 진행(progress) :
임계 구역에 어떤 프로세스도 진입하지 않았다면 진입하고자 하는 프로세스는 들어갈 수 있어야 한다.

3. 유한 대기(bounded waiting) :
 한 프로세스가 임계 구역에 진입하고 싶다면 언젠가는 임계 구역에 들어올 수 있어야 한다.(임계 구역에 들어오기 위해 무한정 대기해서는 안된다.)

 

동기화 기법
뮤텍스 락  세마포 모니터
- 상포 배제를 위한 동기화 도구(탈의실에 있는 자물쇠 역할(사람이 들어있는지 안들어있는지 확인 가능한 역할) - 탈의실 : 임계구역, 손님 : 프로세스) 
- 공유자원이 only 하나일 때 적용 가능
- 좀 더 일반화된 방식의 동기화 도구
- 공유 자원이 여러개 있는 경우에도 적용 가능.
- 임계 구역 앞에서 멈춤 신호를 받으면 잠시 기다리기. 임계 구역앞에서 가도 좋다는 신호를 받으면 임계구역 진입.
- 사용자(개발자)가 다루기에 편한 동기화 도구

뮤텍스 락의 단순한 형태
 : 전역변수 하나, 함수 두개
-----------------------------------------------------
- 자물쇠 역할 :
프로세스들이 공유하는 전역변수 lock
- 임계 구역을 잠그는 역할 :
acquire 함수
- 임계 구역의 잠금을 해제하는 역할 :
release함수
세마포의 단순한 형태
 : 전역변수 하나, 함수 두개
-----------------------------------------------------
- 임계 구역에 진입할 수도 있는 프로세스의 개수(사용 가눙한 공유 자원의 개수)를 나타내는 전역 변수 s
- 임계구역에 들어가도 좋을지, 기다려야 할지를 알려주는 wait함수
- 임계구역 앞에서 기다리는 프로세스에 "이제 가도 좋다"고 신호를 주는 signal함수
- 모니터 안에는 하나의 프로세스만이 있을 수 있다.
> wait()를 호출했던 프로세스는 signal()을 호출한 프로세스가 모니터를 떠난 뒤에 수행을 재개.
> signal()을 호출한 프로세스의 실행을 일시 중단하고 자신이 실행된 뒤 다시 signal()을 호출한 프로세스의 수행을 재개.
ex>
acquire(); //자물쇠 잠겨있는지 확인, 잠겨있지 않다면 잠그고 들어가기
//임계 구역 //임계구역에서의 작업 진행
//여기서 위의 예시 중 총합 변수 접근
release(); //자물쇠 반환
-----------------------------------------------------
acquire 함수 : 프로세스가 임계 구역에 진입하기 전에 호출. 임계 구역이 잠겨있다면 임계구역이 열릴때까지(lock == false) 임계구역을 반복적으로 확인. 임계구역이 열려있다면 임계구역을 잠그기(lock = true)
release함수 : 임계구역에서의 작업이 끝나고 호출. 현재 잠긴 임계구역을 열기(lock을 false로 바꾸기) 
-----------------------------------------------------
* 예시 코드
acquire() {
      while(lock == true) //만약 임계구역이 잠겨잇다면
               ; //임계구역이 잠겨있는지를 반복적으로 확인.
       lock = true ; //만약임계구역이 잠겨있지 않다면 임계구역 잠금
}
release() {
       lock = false; //임계구역 작업이 끝났으니 잠금 해제 
}
-----------------------------------------------------
ex>
wait();
//임계구역
signal();
임계구역 앞뒤로 함수 호출.
-----------------------------------------------------
wait() {
     while( S <=0)  // 만일 임계구역에 진입할 수 있는 프로세스 개수가 0이하라면
        ; // 사용할 수 있는 자원이 있는지 반복적으로 확인하고
     S--; // 임계 구역에 진입할 수 있는 프로세스 개수가 하나 이상이면 S를 1감소 시키고 임계구역에 진입. 
signal() {
       S++; // 임계 구역에서의 작업을 마친 뒤 S를 1 증가시킴.
-----------------------------------------------------
세마포를 활용한 실행 순서 동기화
- 세마포의 변수 S를 0으로 두고, 먼저 실행할 프로세스 뒤에 signal함수. 다음에 실행할 프로세스 앞에 wait함수를 붙이면됨.
- 상호배제를 위한 동기화 : 
>인터페이스를 위한 큐. 
>공유자원에 접근하고자 하는 프로세스를(인터페이스를 위한) 큐에 삽입.
>큐에 삽입된 순서대로(한번에 하나의 프로세스만) 공유 자원 이용 가능.
- 실행 순서 제어를 위한 동기화 : 
> 조건 변수 이용(프로세스나 스레드의 실행 순서를 제어하기 위해 사용하는 특별한 변수)
조건 변수. wait() : 대기 상태로 변경, 조건 변수에 대한 큐에 삽입
조건 변수. signal() : wailt()으로 대기 상태로 접어든 조건 변수를 실행 상태로 변경 
1. 특정 프로세스가 아직 실행될 조건이 되지 않았을 때에는 wait를 통해 실행을 중단한다.
2. 특정 프로세스가 실행될 조건이 충족되었을 때에는 signal을 통해 실행을 재개한다.
- 코드
  while() //만약 임계구역이 잠겨잇다면
               ; //임계구역이 잠겨있는지를 반복적으로 확인.
부분을 바쁜 대기(busy waiting)라 부름 
>>임계 구역에 진입할 수 있는지를 반복적으로 확인하는 것은 CPU사이클 낭비!
---------------------------------------------------------------------------------------------------------------
해결 방법
- 사용할 수 있는 자원이 없을 경우 대기 상태로 만듦
(해당 프로세스의 PCB를 대기 큐에 삽입)
- 사용할 수 있는 자원이 생겼을 경우 대기 큐의 프로세스를 준비 상태로 만듦.
(해당 프로세스의 PCB를 대기 큐에서 꺼내 준비 큐에 삽입)
 

 

728x90
스레드란?
프로세스를 구성하는 실행 흐름의 단위. 하나의 프로세스는 하나 이상의 스레드를 가질 수 있다.
(한 프로세스를 여러 개의 스레드로 동시 실행 가능)
웹브라우저 프로세스 - 화면 출력 스레드, 입력 스레드, 검색 스레드 등등

프로세스와 스레드
- 실행 흐름이 하나인 프로세스(단일 스레드 프로세스)
- 실행 흐름이 여러 개인 프로세스(멀티 스레드 프로세스)
 >> 프로세스를 이루는 여러 명령어 동시 실행 가능.

스레드의 구성요소
: 스레드 ID, 프로그램 카운터를 비롯한 레지스터 값, 스택 등. 실행에 필요한 최소한의 정보를 가지고 있음.
모든 스레드들은 프로세스의 자원을 공유한다. 
멀티 프로세스와 멀티 스레드
동일한 작업을 수행하는 단일 스레드 프로세스 여러 개 실행(멀티프로세스)vs 하나의 프로세스를 여러 스레드로 실행(멀티 스레드) >> 차이는?
멀티프로세스 : 남남처럼(자원 공유 X) 실행
- 프로세스를 fork 하면 코드/ 데이터/ 힙 영역등 모든 자원이 복제되어 저장됨.
- 저장된 메모리 주소를 제외하면 모든 것이 동일한 프로세스 두 개가 통째로 메모리에 적재
- fork를 세번, 네 번 하면 메모리에는 같은 프로세스가 통째로 세 개, 네 개 적재
참고) fork 직후 같은 프로세스를 통째로 메모리에 중복 저장하지 않으면서동시에 프로세스끼리 자원을 공유하지 않는 방법도 있다. 이를 쓰기 시 복사(copy on write) 기법이라 한다.
- PCB값 멀티 프로세스의 스레드들은 다 다름, 멀티 스레드의 PCB값은 하나 
- 스레드들은 각기 다른 스레드 ID, (별도의 실행을 위해 꼭 필요한) 프로그램 카운터 값을 포함한 레지스터 값, 스택을 가질 뿐 프로세스가 가지는 자원을 공유 

>>프로세스끼리는 자원을 공유하지 않는다. --> 남남처럼 독립적으로 실행된다.
프로세스 간에도 자원을 주고 받을 수 있다 : 프로세스 간 통신(IPC)
파일을 통한 프로세스 간 통신, 공유 메모리를 통한 프로세스 간 통신.(프로세스끼리 공유하는 메모리를 따로 둠)
>> 스레드는 프로세스의 자원을 공유한다. --> 협력과 통신에 유리하다. 때로는 자원을 공유하고 있다는 게 문제가 될 수도 있음.

 

728x90
프로세스 상태
생성 상태 - 이제 막 메모리에 적재되어 PCB를 할당 받은 상태
- 준비가 완료되었다면 준비상태로 됨
준비 상태 - 당장이라도 CPU를 할당 받아 실행할  수 있지만 자신이 차례가 아니기에 기다리는 상태.
- 자신의 차례가 된다면 실행상태로 됨(== 디스패치)
실행 상태 - CPU를 할당 받아 실행 중인 상태.
- 할당된 시간 모두 사용 시(타이머 인터럽트 발생시) 준비상태로, 실행 도중 입출력 장치를 사용하면 입출력 작업이 끝날 때까지 대기 상태로 됨.
대기 상태 - 프로세스가 실행 도중 입출력 장치를 사용하는 경우
- 입출력 작업은 CPU에 비해 느리기에 이 경우 대기 상태로 접어듬. 입출력 작업이 끝나면(입출력 완료 인터럽트를 받으면) 준비상태로 접어듬.
종료 상태 - 프로세스가 종료된 상태
- PCB, 프로세스의 메모리 영역 정리 

 

프로세스 상태 다이어그램

프로세스 상태 다이어그램

프로세스 계층구조
  • 프로세스 실행 도중(시스템 호출을 통해) 다른 프로세스 생성 가능
  • 새 프로세스를 생성한 프로세스 : 부모 프로세스
  • 부모 프로세스에 의해 생성된 프로세스 : 자식 프로세스
- 부모 프로세스와 자식 프로세스는 별개의 프로세스이므로 각기 다른 PID를 가짐.
- 일부 운영체제에서는 자식 프로세스 PCB에 부모 프로세스 PID(PPID)를 명시하기도 함. 
- 자식 프로세스는 또 다른 자식 프로세스를 낳을 수 있고, 그 자식프로세스는 또 다른 자식 프로세스르 낳을 수 있음. >> 프로세스의 계층적인 구조 형성. 

 

프로세스 생성 기법

부모 프로세스는 자식 프로세스를 어떻게 만들어내고, 자식 프로세스는 어떻게 자신만의 코드를 실행할까?

>> 복제와 옷 갈아입기

Fork-exec

  • 부모 프로세스는 fork 시스템 호출을 통해 자신의 복사본을 자식 프로세스로 생성
  • 자식 프로세스는 exec 시스템 호출을 통해 자신의 메모리 공간을 다른 프로그램으로 교체 
fork 시스템 호출 fork는 자기 자신 프로세스의 복사본을 자식 프로세스로 생성하는 시스템 호출이다.
- 복사본(= 자식 프로세스) 생성
- 부모 프로세스의 자원 상속
exec 시스템 호출 exec는 자신의 메모리 공간을 새로운 프로그램으로 덮어쓰는 시스템 호출이다.
- 메모리 공간을 새로운 프로그램으로 덮어쓰기
- 코드/ 데이터 영역은 실행할 프로그램 내용으로 바뀌고 나머지 영역은 초기화

 

728x90
실행 중인 프로 그램, "프로세스"

 

프로세스
: 포그라운드 프로세스와 백그라운드 프로세스로 나뉜다.
포그라운드 프로세스 사용자가 볼 수 있는 공간에서 실행되는 프로세스 메모장, 웹브라우저
백그라운드 프로세스 사용자가 볼 수 없는 공간에서 실행되는 프로세스
사용자와 상호작용하지 않고 그저 정해진 일만 수행하는 프로세스
데몬, 서비스로도 불림.

 

프로세스 제어 블록
: 프로세스 관련 정보를 저장하는 자료구조
모든 프로세스는 실행을 위해 CPU가 필요하지만 CPU자원은 한정되어 있다.
프로세스들은 돌아가며 한정된 시간만큼만 CPU이용한다. - 자신의 차례에 정해진 시간만큼 CPU이용, 타이머 인터럽트가 발생하면 차례 양보.

빠르게 번갈아 수행되는 프로세스들을 관리해야 하며 이를 위해 사용하는 자료구조가 프로세스 제어 블록(이하 PCB)이다.
프로세스 관련 정보를 저장하는 자료구조. 프로세스 생성 시 커널 영역에 생성, 종료 시 폐기.
프로세스 제어 블록에 담기는 대표적인 정보
프로세스 ID( = PID)
: 특정 프로세스를 식별하기 위해 부여하는 고유한 번호(학교의 학번같은 거)
레지스터 값
: 프로세스는 자신의 실행 차례가 오면 이전까지 사용한 레지스터 중간 값을 모두 복원. >> 실행재게

프로세스 상태
: 입출력 장치를 사용하기 위해 기다리는 상태. CPU를 사용하기 위해 기다리는 상태, CPU이용중인 상태
CPU 스케줄링 정보
: 프로세스가 언제, 어떤 순서로 CPU를 할당 받을 지에 대한 정보
메모리 정보
: 프로세스가 어느 주소에 저장 되어 있는 지에 대한 정보. 페이저 테이블 정보(== "메모리 현재주소를 알 수 있는 정보가 담기는 군") 
사용한 파일과 입출력 장치 정보
: 할당된 입출력 장치. 사용중인(열린) 파일 정보

운영체제는 커널 영역에 적재된 프로세스 제어 블록 (PCB)를 보고 프로세스를 관리.

 

문맥 교환(context switch)
한 프로세스에서 다른 프로세스로 실행 순서가 넘어가면?
- 기존에 실행되던 프로세스는 지금까지의 중간 정보를 백업(프로그램 카운터 등 각종 레지스터 값, 메모리 정보, 열었던 파일, 사용한 입출력 장치 등)
          - 이러한 중간 정보 == 문맥
          - 다음차례가 왔을 때 실행을 재개하기 위한 정보
          - 실행 문맥을 백업해두면 언제든 해당 프로세스의 실행을 재개할 수 있다!
- 뒤이어 실행할 프로세스의 문맥을 복구
          - 자연스럽게 실행 중인 프로세스가 바뀜 
  • 이처럼 기존의 실행 중인 프로세스 문맥을 백업하고 새로운 프로세스 실행을 위해 문맥을 복구하는 과정을 문맥 교환 이라 한다.(여러 프로세스가 끊임없이 빠르게 번갈아 가며 실행되는 원리)

프로세스의 메모리 영역

: 크게 코드 영역(=텍스트영역), 데이터 영역, 힙 영역, 스택 영역

프로세스의 메모리 영역  
코드 영역(= 텍스트 영역) - 실행할 수 있는 코드, 기계어로 이루어진 명령어 저장
- 데이터가 아닌 CPU가 실행할 명령어가 담기기에 쓰기가 금지된 영역(read- only)
크기가 고정되어 있는 영역
(== 정적 할당 영역)
데이터 영역 - 잠깐 썼다가 없앨 데이터가 아닌 프로그램이 실행되는 동안 유지할 데이터 저장
- e.g. 전역변수 
힙 영역 - 프로그램을 만드는 사용자, 즉 프로그래머가 직접 할당할 수 있는 저장공간
- 메모리 공간을 할당했을 때 언젠가는 이 공간을 반환해야 함. 이걸 대신 해주는게 c#에는 가비지 콜렉션이란 기능이 있음, 하지만 c언어같은 경우는 직접해줘야 함 이걸 안해주면 메모리 누수가 일어날 수 있음.
크기가 가변적으로 변할수 있는 영역
(== 동적 할당 영역)

- 일반적으로 힙 영역은
낮은 주소 >> 높은 주소로 할당
- 일반적으로 스택영역은
높은 주소 >> 낮은 주소로 할당
- 주소가 겹치지 않게 하기 위해 힙과 스택은 할당되는 방향이 반대되는 방향으로 차오름.
스택 영역 - 데이터가 일시적으로 저장되는 공간
- (데이터 영역에 담기는 값과는 달리) 잠깐 쓰다가 말 값들이 저장되는 공간.
- e.g. 매개변수, 지역변수 

 

728x90

+ Recent posts