당신은 주제를 찾고 있습니까 “우선 순위 스케줄링 – [시나공 정보처리] 1417100 주요 스케줄링 알고리즘“? 다음 카테고리의 웹사이트 https://you.charoenmotorcycles.com 에서 귀하의 모든 질문에 답변해 드립니다: https://you.charoenmotorcycles.com/blog/. 바로 아래에서 답을 찾을 수 있습니다. 작성자 길벗시나공 IT 이(가) 작성한 기사에는 조회수 2,588회 및 좋아요 27개 개의 좋아요가 있습니다.
우선 순위 스케줄링 주제에 대한 동영상 보기
여기에서 이 주제에 대한 비디오를 시청하십시오. 주의 깊게 살펴보고 읽고 있는 내용에 대한 피드백을 제공하세요!
d여기에서 [시나공 정보처리] 1417100 주요 스케줄링 알고리즘 – 우선 순위 스케줄링 주제에 대한 세부정보를 참조하세요
시나공 카페에서는 최신기출문제와 해설, 시험대비자료, 합격 전략 및 수기, 자격증 관련 문의 및 자료 등 IT 자격증 시험을 위한 모든 정보를 제공합니다.\r
카페 주소 : https://sinagong.gilbut.co.kr/it/
우선 순위 스케줄링 주제에 대한 자세한 내용은 여기를 참조하세요.
[운영체제] 17. 우선순위 스케줄링(Priority 스케줄링) 알고리즘
우선순위 스케줄링은 다음 그림과 같이 준비 큐에 프로세스가 도착하면, 도착한 프로세스의 우선순위와 현재 실행 중인 프로세스의 우선순위를 비교 …
Source: wonit.tistory.com
Date Published: 6/23/2022
View: 1835
[운영체제 OS]우선순위 스케줄링(Priority Scheduling) 총정리 …
Priority scheduling은 말 그대로 우선순위가 높은 프로세스를 먼저 스케줄링 하는거예요. 근데 문제는 뭘까요? 문제는 Priority를 어떻게 주느냐가 이제 …
Source: jhnyang.tistory.com
Date Published: 1/14/2022
View: 312
[운영체제] 스케줄링(Scheduling) 알고리즘(FIFO, SJF, 우선순위 …
우선순위 스케줄링은 프로세스마다 우선순위라는 속성이 붙게 됩니다. 우선순위 스케줄링도 역시 선점, 비선점형으로 스케줄링이 가능합니다. 숫자가 높을 …
Source: reakwon.tistory.com
Date Published: 12/30/2021
View: 3207
9. 스케줄링 알고리즘과 우선순위 – velog
대부분의 운영체제는 멀티 프로세스 기반 운영체제이며, 실행중인 모든 프로세스들에게 골고루 CPU를 할당하는 일은 운영체제의 일부분에 담당하는 …
Source: velog.io
Date Published: 3/23/2021
View: 6895
우선순위 스케줄링 – Keep going
우선순위 스케줄링. 코딩천재홍 2021. 4. 20. 01:30. Priority Scheduling. 각 프로세스에 우선순위 지정 – 우선순위를 부여하는 것; 각 Process에 우선순위가 부여 …
Source: hdg3052.tistory.com
Date Published: 4/16/2021
View: 7870
[09. 스케줄링 알고리즘과 우선순위] – 어떤 프로그래머
프로세스의 스케줄링(Scheduling) · 이러한 상황을 기아(Starvation)상태라 한다. · 우선순위 스케줄링 알고리즘은 우선순위가 높은 프로세스를 먼저 실행 …
Source: popcorntree.tistory.com
Date Published: 9/10/2022
View: 1516
스케줄링 알고리즘(Scheduling Algorithm) – Crocus
우선순위 스케줄링은 프로세스가 Ready Queue에 도착하면 우선순위를 비교하여 우선순위가 가장 높은 프로세스에 프로세서(CPU)를 할당하는 방식이다.
Source: www.crocus.co.kr
Date Published: 9/10/2022
View: 5232
CPU 스케줄링 (3) – 우선순위 스케줄링 – 코딩스낵
Priority(우선순위) 스케줄링은 말 그대로 우선순위 순서대로 스케줄링을 진행하는 것이다. 우선순위는 정수값으로 주어지며 일반적으로 낮은 숫자가 높은 …
Source: gusdnd852.tistory.com
Date Published: 2/26/2021
View: 3713
우선순위 스케줄링 – 제타위키
우선순위가 높은 프로세스에 CPU를 우선 할당하는 스케줄링 방식; 우선순위가 같으면 … 예를 들어 SJF 스케줄링은 버스트 시간이 짧을수록 우선순위를 높게 책정하는 …
Source: zetawiki.com
Date Published: 6/16/2021
View: 7316
#3 – 2) 스케줄링 기법 및 종류와 Aging(에이징) 기법
#4. 우선순위(Priority) … 넣는 방식이다. … 비교하게 되고, 우선순위가 가장 높은 프로세스를 대기 상태의 첫 번째로 배치하게 된다. – 즉, 현재 실행 …
Source: yabmoons.tistory.com
Date Published: 6/26/2022
View: 8234
주제와 관련된 이미지 우선 순위 스케줄링
주제와 관련된 더 많은 사진을 참조하십시오 [시나공 정보처리] 1417100 주요 스케줄링 알고리즘. 댓글에서 더 많은 관련 이미지를 보거나 필요한 경우 더 많은 관련 기사를 볼 수 있습니다.
![[시나공 정보처리] 1417100 주요 스케줄링 알고리즘](https://i.ytimg.com/vi/CIQ8gifvPGs/maxresdefault.jpg)
주제에 대한 기사 평가 우선 순위 스케줄링
- Author: 길벗시나공 IT
- Views: 조회수 2,588회
- Likes: 좋아요 27개
- Date Published: 2021. 4. 17.
- Video Url link: https://www.youtube.com/watch?v=CIQ8gifvPGs
[운영체제] 17. 우선순위 스케줄링(Priority 스케줄링) 알고리즘
운영체제의 스케줄링 알고리즘을 평가하기 위해서는 다음과 같은 특성을 충분히 이해해야 한다.
프로세서 사용률
프로세서를 항상 실행상태로 유지하여 유휴 상태가 되지 않도록 한다.
처리율
단위 시간당 완료하는 작업의 수가 많도록 하여 짧은 작업을 우선 처리하거나 인터럽트 없이 처리한다
반환 시간
작업이 메모리에 들어가기 까지 걸린 시간, 준비 큐에 머무르는 시간, 실행 시간, 입출력 시간 등 작업을 완료하는데 소요된 시간
대기 시간
프로세스가 실행이 되기 전 까지 대기되는 시간을 뜻한다.
반응 시간
작업을 요청한 시간부터 반응을 시작하는 시간까지의 간격
우선순위 스케줄링 (Priority Scheduling)
우선순위 스케줄링은 다음 그림과 같이 준비 큐에 프로세스가 도착하면, 도착한 프로세스의 우선순위와 현재 실행 중인 프로세스의 우선순위를 비교하여 우선순위가 가장 높은 프로세스에 프로세서를 할당하는 방식이다.
그럼 만약 우선순위가 동일한 프로세스가 준비 큐로 들어오게 되면 FIFO 의 순서로 스케줄링을 하게 된다.
우선순위의 선점과 비선점
또한 우선순위 스케줄링은 선점 또는 비선점이 존재하기 때문에 이 둘을 나눠서 생각해야 한다. 선점과 비선점의 방식도 동일하게 도착한 프로세스의 우선순위를 보고 구분을 하는데 기존 프로세스보다 우선순위가 높으면 할당한다.
우선순위 결정법
우선순위는 내부적, 외부적으로 정의할 수 있다.
내부적 우선순위 결정
제한 시간, 기억장소 요청량, 사용 파일 수, 평균 프로세서 버스트에 대한 평균 입출력 버스트의 비율
외부적 우선순위 결정
프로세스의 중요성, 사용료를 많이 낸 사용자, 작업을 지원하는 부서, 정책적 요인
장점
각 프로세스의 상대적 중요성을 정확히 정의할 수 있다.
다양한 반응으로 실시간 시스템에 사용 가능하다.
단점
높은 우선수위 프로세스가 프로세서를 많이 사용하면 우선순위가 낮은 프로세스는 무한정 연기되는 기아가 발생한다.
우선순위 스케줄링의 실행
준비 큐에 다음과 같은 프로세스들이 들어왔다고 가정한다. 유념해야 할 것이 우선순위는 높을 수록 빨리 처리가 된다. 1이라고 해서 1순위가 아니라는 소리다.
이를 토대로 간트 차트를 그려본다면 다음과 같다.
선점 우선순위 간트 차트 및 반환 시간
p1 프로세스가 준비 큐에 들어오고 기존 준비 큐에 프로세서를 점유하는 프로세스가 없기 때문에 실행한다.
1초에 p2 가 들어오는데 우선순위가 p1 보다 낮기 때문에 프로세서는 p1 을 계속 점유한다.
2초에 p3 가 들어오는데 우선순위가 p1 보다 높기 때문에 프로세서는 p3 를 점유한다.
3초에 p4 가 들어오는데 우선순위가 p2 보다 낮기 때문에 프로세서는 p3 를 점유한다.
4초에 p5 가 들어오는데 우선순위가 p2 보다 낮기 때문에 프로세서는 p3 를 점유한다. 이제 모든 프로세스가 준비 큐에 들어왔다.
p3 의 실행이 끝나고 우선순위를 확인하는데 p2 의 우선순위와 p5 의 우선순위가 같지만 FIFO로 인해 p2 를 실행한다.
…반복
반환 시간 및 대기 시간
비선점 우선순위 간트 차트 및 반환 시간
p1 프로세스가 준비 큐로 들어오고 기존 준비 큐에 프로세서를 점유하는 프로세스가 없기 때문에 실행한다.
p1 이 끝날 때 까지 어떤 프로세스도 점유할 수 없기 때문에 p1 이 끝나길 기다린다.
p1 이 끝나고 그 다음 우선순위가 높은 p3 를 점유한다.
p3 가 끝나고 그 다음 우선순위가 높은 p2 를 점유한다.
…반복
반환 시간 및 대기 시간
문제점과 에이징 방법
우선순위 알고리즘의 주요한 문제는 무한 정지와 기아상태 이다.
예를 들어 실행 준비가 되었으나 우선순위가 높은 프로세스가 계속 들어오면 우선순위가 낮은 프로세스는 무한정 대기해야 하는 상황이 발생한다. 이러한 기다림을 해결하는 방법이 바로 에이징이다.
에이징은 매 분마다 대기 중인 프로세스의 우선순위를 1씩 증가시킨다.
그러면 초기에 우선순위가 0이었단 프로세스가 대기중이면 프로세서를 점유중인 프로세스보다 우선순위가 높아지는 시점이 발생하여 무한 정지와 기아상태를 해결할 수 있다.
이를 그래프로 나타내면 다음과 같다.
[운영체제 OS]우선순위 스케줄링(Priority Scheduling) 총정리,장단점, aging 스케줄링, 우선순위 부여기준
반응형
[운영체제 목차]안녕하세요!! 오늘은 우선순위 스케줄링에 관한 내용을 들고 왔어요 ㅎㅎ
우선순위 스케줄링이란? 우선순위 알고리즘이 나오게 된 흐름!
이전 SJF가 되었던 SRTF가 되었던 이 스케줄링 방식은 우리 컴퓨터 방식에는 적용하기가 힘들다는 단점이 있었어요!!
한번 흐름을 다시 볼까요?
waiting time을 줄여야 하는데 waiting time이 FCFS가 좀 컸어요 그래서 FCFS를 사용 못했죠?
근데 waiting time을 줄이려고 SJF를 썼더니 이거는 또 쓸 수가 없어!! 예측하기가 너무 힘들다는 문제가 있었어요. 그 다음에 우리가 살펴볼 알고리즘이 Priority scheduling!!
우선순위 스케줄링이란?
Priority scheduling은 말 그대로 우선순위가 높은 프로세스를 먼저 스케줄링 하는거예요.
근데 문제는 뭘까요? 문제는 Priority를 어떻게 주느냐가 이제 문제겠죠!
사실 맥락만 바꾸면 이 우선순위 스케줄링은 FCFS가 될 수도 있고 SJF가 될 수도 있는 특징을 지녔어요.
priority를 가장 먼저 온 얘한테 높은 우선순위를 주는게 FCFS고 Cpu burst가 작은 것에 우선순위를 주는 것이 SJF겠죠!! (사진의 세번째 네모가 설명하고 있는 부문이예요)
우리 컴퓨터에서는 priority 스케줄링을 어떻게 주냐면 그 프로세스의 중요도를 기준으로 부여합니다.
첫 번째 네모를 보면 우선순위 알고리즘 특징을
‘A priority number(integer) is associated with each process’라고 했어요.
그 프로세스의 중요도 별로 우선순위를 준다! 그래서 우선순위 스케줄링은 그 중요도가 높은 프로세스를 먼저 수행을 합니다.
자 예를 들어볼까요?
운영체제가 만들어내는 프로세스들이 있어요, 운영체제 서비스.
그거하고 여러분들이 프로그램을 실행해서 만드는 프로세스가 있어요.
그 두 개의 프로세스 중 어떤 프로세스의 우선순위를 높이는 것이 맞을까요?ㅎㅎㅎ
운영체제가 판단하길, 여러분들이 실행시키는 것들은 하찮은 것들입니다 ㅎㅎㅎ. (실제로 제일 낮은 우선순위를 갖거든요..주륵)
운영체제가 만들어내는 프로세스들의 우선순위를 일반적으로 더 높이 줍니다.
프로세스의 어떤 의미, 의미(sementic)에 따라 우선순위를 주고 높은 프로세스를 스케줄링 하는 방법이 Priority scheduling이라 합니다
우선순위는 어떻게 정해지나요?
Priorities can be defined either internally or externally.
우선순위는 내부적으로 정의될 수도 있고 외부적으로 정의될 수도 있습니다.
내부적으로 정의된 우선순위는, 프로세스의 우선순위를 계산하기 위해 어떤 측정가능한 변수들을 사용해요. 예를 들면, 시간 제한, 메모리 요구량, 열린 파일의 수, 평균 I/O burst비율부터 평균 CPU 버스트 비율까지! 다 우선순위를 계산하는데 종합적으로 사용됩니다.
External 우선순위는 말 그대로 운영체제가 스스로 정하는게 아니라 바깥에 이미 설정된 기준을 따르는거예요!
우리가 프로세스의 우선순위를 임의로 설정할 수도 있는데 당근 external설정에 해당되겠죠?
the type and amount of funds being paid for computer use, the department sponsoring the work, and other,oftenpolitical,factors.
프로세스의 중요도, 자원의 유형이나 들어가는 자원의 비용, 사용자 선호도, 가끔은 정치적 요소들부터..등등
preemptive vs nonpreemptive
Priority scheduling can be either preemptive or nonpreemptive.
우선순위 스케줄링 또한 선점방식과 비선점 방식 두 방법이 가능합니다.
preemptive 우선순위 스케줄링
: 만약 어떤 프로세스가 ready queue에 도착했는데 이 프로세스가 가지는 우선순위가 현재 돌아가고 있는 프로세스보다 높을 경우 기존에 하고 있던애를 중단시키고 먼저 수행되는!! 이게 선점 방식이 되겠죠?
nonpreemptive 우선순위 스케줄링
:비선점 방식은 중단을 못시킨다고 했잖아요! ㅎㅎ 즉 더 높은 우선순위가 들어오면 ready queue의 앞에 집어넣고 끝날때까지 기다립니다. 그럼 바로 다음에 수행될 수 있겠죠!
우선순위 문제 보고 가기
문제를 볼까요?
낮은 숫자가 높은 우선순위를 갖는다는 전제하에 프로세스가 어떤 순서로 스케줄링 되는지 살펴봅시다. 평균기다림 시간을 구해볼까요?ㅎㅎ
일단 가장 높은 우선순위를 갖는 P2가 먼저 수행되겠죠? 그리고 그 다음인 P5, 그 다음으로 우선순위가 높은 P1이 순서대로 수행됩니다. ㅎㅎ 정답 구하는건 너무 쉬워요
그래서 평균 waiting time은 ( 0+1+6+16+18)/5 = 8.2ms가 될거예요
우선순위 알고리즘의 단점?! 문제점 – starvation
이렇게 보면 여기 문제가 starvation이라고 나와 있듯이 우선순위가 낮은 프로세스는 높은 프로세스가 있는 한은 절대 실행을 못하는 것이 문제가 됩니다. ㅎㅎㅎ
무한히 기다리는 것=starvation.
쉬운 설명을 위해 예를 들어볼게요.
여러분들이 식당에 가서 줄을 서가지고 밥을 먹는데 거기에서의 스케줄링은 Priority scheduling이라고 가정해봅시다. (고등학교 때 학년별로 급식을 먹지 않았었나요? ㅎㅎ 저희는 그랬는뎅…이 때 3학년은 2학년보다 높은 우선순위를 갖기 때문이었겠죠 ㅎㅎ)
즉 중요도에 의해서 Priority를 다 매겨놨어요. 선생님들은 당연히 우선순위가 더 높겠죠? 그 다음에 3학년들 학년별로.. 이렇게 우선순위를 가진다고 할게요. 1학년이 줄 서있었는데 계속 자기보다 높은 우선순위를 가진 사람들이 앞으로 들어오면(인원이 제한 된 수가 아니라면) 자신은 스케줄링을 못 받아가지고 계속 쫄쫄 굶겠죠? starvation이 되는 거죠!!
우선순위 알고리즘 문제 starvation 해결 방법- aging 에이징
어떻게 해결해야 될까요? 알고리즘으로 만들어보는 걸 생각해 봅시다.
Priority를 나이로 주자고 했다면 내 앞에 한 사람이 들어가면 내 나이가 한 살 더 많아지는 방법이 있을 수 있겠죠. 또 한명이 들어가면 내 나이가 많아지고 많아지고 하다보면 50대 선생님이 오더라도 내가 더 나이가 많아질 수 있을거예요. 이래서 aging입니다!
solution이 aging. aging이라는 알고리즘이 존재를 합니다. 이런식으로 Priority scheduling의 단점을 해결할 수도 있다는거~!
우선순위 스케줄링의 구조
priority별로 queue가 있는데
참고로 어떤 책에서는 priority는 0번이 제일 높고 어떤 책에서는 Priority 0번이 제일 낮을 수도 있어요.
Priority가 0번이 더 높은 경우가 더 많이 있는데 이 그림은 4가 제일 높은거겠죠?ㅎㅎ.
Priority 별로 queue가 있고 priority가 높은 쪽에 있는 process가 ready가 있으면 다른 것들은 수행이 안됩니다. 이 때 Priority가 똑같은 것들은 어떻게 해야 될까? 우리가 지금 배운 것으로는 FCFS로 할 수도 있고 FJS로 할 수도 있고~!! 근데 지금 현재 우리가 취하고 있는 방법은 Round Robin이다.
즉 현재 컴퓨터 시스템이 사용하는 방법은 ‘우선순위스케줄링 +라운드 로빈’ 방식!!
후 오늘도 긴 포스팅이었다. 정말 시간이 훅훅 지나가는 것 같아요!
가끔 운영체제 포스팅 보고 도움 많이 됐다는 댓글을 볼때마다 뿌듯하답니다 ㅎㅎ 그래서 배운지 오래됐지만 쪼끔씩이나마 틈틈히 써서 완성시켜보려고 해요! 시간이 넘 지나서 혹시 잘못된 점이 있을 수도, 오타가 있을 수도 있어요 ㅎㅎ 알려주시면 감사하겠습니다.
도움이 됐다면 보답광고&공감&댓글은 어떤가요?ㅎㅎ 오늘도 좋은 하루 되세요~!!
반응형
REAKWON :: [운영체제] 스케줄링(Scheduling) 알고리즘(FIFO, SJF, 우선순위, Round-robin)
스케줄링의 개념
단일 처리 시스템에서는 실행 중인 프로세스(A)가 존재하는데 다른 프로세스(B)가 입출력을 요청하면 그 프로세스(B)는 이전의 프로세스(A)의 자원을 놓을때까지 대기하고 있어야합니다. 하지만 다중 프로그래밍에서는 여러 프로세스들이 동시에 돌아갈 수 있으며, 프로세스가 자원(프로세서 등)을 요청하면 운영체제는 그 자원을 적절히 분배하여 프로세스에게 할당합니다. 그래서 다음과 같은 장점을 얻을 수 있습니다.
1. CPU의 활용 극대화
2.프로세스 처리율(시간 당 작업량)을 늘릴 수 있습니다.
프로세스는 필요한 자원을 할당받기 위해 큐에 대기합니다. 그래서 그 큐에 있는 프로세스를 어떻게 스케쥴링하는지가 프로세스 스케줄링 알고리즘이라고 합니다. 그레서 어떤 스케줄링 알고리즘이 있는지 봅시다.
잠깐 프로세스 스케줄링에 관한 용어 몇가지만 알아보고 가도록 합시다. 대기 시간, 실행 시간, 반환 시간입니다.
용어 설명 대기 시간 자원의 할당을 대기하는 시간을 의미합니다. 실행 시간 실제로 프로세스가 자원을 할당받은 다음 작업을 수행하는 시간을 의미합니다. 반환 시간 작업을 완료하는데 소요되는 전체 시간으로 대기 시간과 실행 시간을 모두 포함합니다.
1 선입선처리 스케줄링(First Come First Served, First In First Out)
선입선처리(FCFS, FIFO) 알고리즘은 말 그대로 먼저 요청한 프로세스가 먼저 자원을 제공받으며 이미 사용중이라면 사용이 끝날때까지 기다려야하는 스케줄링 방식입니다.
프로세스 5개가 있고, 각가 P1의 실행시간 10, P2의 실행시간 5, P3의 실행시간 6, P4의 실행시간 9, P5의 실행시간 10이라고 할때 반환 시간을 알아보도록 하죠.
프로세스 도착 시간 실행 시간 P1 0 10 P2 1 28 P3 2 6 P4 3 4 P5 4 14
먼저 요청한 프로세스가 먼저 제공받으니 P1부터 차례대로 자원을 할당받습니다. 그래서 프로세스의 반환시간과 대기시간을 구하면 아래와 같습니다.
프로세스 반환시간 대기시간 P1 10 0 P2 37 9 P3 42 36 P4 45 41 P5 58 44 평균 평균 반환 시간
(10+37+42+45+58)/5 = 38.4 평균 대기 시간
(0+9+36+41+44)/5 =
26
장점 1) 스케줄링이 단순합니다.
2) 모든 프로세스가 실행될 수 있습니다.
3) 프로세서가 지속적으로 유용한 프로세스를 수행하여 처리율이 높습니다. 단점 1) 비선점방식의 스케줄링이므로 대화형 작업에는 부적합합니다.
2) 만약 어떤 프로세스의 수행시간이 길면 대기시간이 늘어납니다. 그래서 짧고 간단한 작업은 계속 기다려야합니다.
2. 최소 작업 우선 스케줄링(Shortest Job First)
프로세스의 실행 시간을 이용하여 가장 짧은 시간을 갖는 프로세스가 먼저 자원을 할당받는 방식입니다. 이 방식은 선점할 수도 있는 스케줄링 방식입니다. 이전에 FIFO방식은 중간에 다른 프로세스가 들어오면 그 프로세스는 대기해야했죠? 이 스케줄링 방식은 선점 또는 비선점이 가능합니다. 위와 같은 프로세스라고 할때 비선점형 SJF 스케줄링의 결과는 아래와 같습니다.
프로세스 반환시간 대기시간 P1 10 0 P2 61 33 P3 18 12 P4 11 7 P5 30 16 평균 평균 반환 시간
(10+61+18+11+30)/5 = 26 평균 대기 시간
(0+33+12+7+16)/5 = 13.6
자 P1이 먼저 요청해서 자원을 할당받아 놓은 상태인데, P2가 도착합니다. 비선점형이기 때문에 P2는 우선 기다리고 있는데 P1의 작업이 끝나기 전에 P3, P4 ,P5의 요청이 도착하네요. 그러면 실행 시간이 가장 작은 P4가 자원을 할당받아 쓰고 그 다음인 P3이 자원을 할당받아 사용합니다. 이렇게 되면 위와 같은 결과가 도출되지요.
그렇다면 비선점형 SJF는 어떨까요? 아래의 표가 선점형 SJF의 결과입니다.
프로세스 반환시간 대기시간 P1 20 10 P2 61 33 P3 10 5 P4 4 0 P5 30 16 평균 평균 반환 시간
(20+61+10+4+30)/5 = 25 평균 대기 시간
(10+33+4+0+16)/5 = 12.6
이해를 돕기 위해서 아래의 간트 차트를 보세요. P1이 먼저 도착해서 수행하고 있는 와중에 P2가 도착하는데요. P2는 수행되어야할 시간이 P1보다 크니 P1은 계속 작업을 수행합니다. 그러다가 P3가 도착하는데 P1이 수행해야할 시간보다 P3의 수행시간이 더 짧으니 P3가 작업을 수행합니다. 그런데 P4가 다음에 도착하네요. P4가 더 적은 시간을 갖으니 P4를 수행합니다. 이때 P4가 끝나면 남아있는 프로세스 중에서 가장 적은 수행시간을 갖는 P3의 작업을 이어서 하게 됩니다.
장점 1) 항상 짧은 작업을 먼저 처리하게 되니까 평균 대기시간이 가장 짧습니다. 단점 1) 수행시간이 긴 작업은 짧은 작업에 밀려 기아가 발생합니다.
2) 실행 시간을 예측할 수 없어 실용적이지 못합니다.
3) 짧은 작업이 먼저 실행되므로 공정하지 못한 정책입니다.
3. 우선순위 스케줄링
우선순위 스케줄링은 프로세스마다 우선순위라는 속성이 붙게 됩니다. 우선순위 스케줄링도 역시 선점, 비선점형으로 스케줄링이 가능합니다. 숫자가 높을 수록 우선순위가 높고 만약 우선순위가 같다면 FIFO방식으로 동작합니다.
프로세스 도착 시간 실행 시간 우선순위 P1 0 10 3 P2 1 28 2 P3 2 6 4 P4 3 4 1 P5 4 14 2
그래서 아래는 선점형에서의 결과를 나타낸 표입니다. 약간 헷갈릴 수 있을텐데요. P1 먼저 수행하다가 P3가 오면 우선 순위가 P3가 더 높으니까 P1은 대기하고 P3가 작업을 수행합니다.
프로세스 반환시간 대기시간 P1 16 6 P2 43 15 P3 6 0 P4 59 55 P5 54 40 평균 평균 반환 시간
(16+43+6+59+54)/5 = 35.6 평균 대기 시간
(6+15+0+55+40)/5 = 23.2
다음은 비선점형일때의 결과 표입니다.
프로세스 반환시간 대기시간 P1 10 0 P2 43 15 P3 14 8 P4 59 55 P5 54 40 평균 평균 반환 시간
(10+43+14+59+54)/5 = 36 평균 대기 시간
(0+15+8+55+40)/5 = 23.6
만약 우선순위가 낮은 프로세스가 높은 프로세스에 의해 실행이 되고 있지 않은 상황이라면 어떻게 될까요? 이때는 그 프로세스의 우선순위를 점차 높여 처리받게끔 하는 에이징이라는 기법을 사용합니다.
장점 1) 각 프로세스의 중요성에 따라서 작업을 수행하기 때문에 합리적입니다.
2) 실시간 시스템에서 사용가능합니다. 단점 1) 높은 우선순위를 갖는 프로세스가 계속적으로 스케줄링이 되면 우선순위가 낮은 프로세스는 자원을 할당받지 못하기 때문에 기아가 발생할 수 있습니다.
4. 라운드 로빈 스케줄링(Round-Robin)
라운드 로빈 스케줄링은 시분할 시스템을 위해 설계된 스케줄링 기법입니다. 이 스케줄링은 작은 단위의 시간인 시간 할당량(Time-Slice)을 정의하여 그 시간 만큼 자원을 할당하는 방식입니다. 그래서 그 시간안에 작업을 끝내지 못하면 다음 프로세스가 다시 그 시간만큼 자원을 할당받아씁니다. 여기서 시간 할당량을 5로 정하고 간트 차트와 결과를 보면 아래와 같습니다.
각 프로세스들은 공정하게 5만큼의 시간 동안 작업을 진행하는 것을 볼 수 있네요.
프로세스 반환시간 대기시간 P1 29 19 P2 61 33 P3 33 27 P4 16 7 P5 45 31 평균 평균 반환 시간
(29+61+33+16+45)/5 = 36.8 평균 대기 시간
(19+33+27+7+31)/5 = 23.4
장점 1) 모든 프로세스가 공정하게 스케줄링을 받을 수 있습니다.
2) 실행 큐에 프로세스의 수를 알고 있을때 유용합니다.
3) 프로세스의 짧은 응답시간을 갖고 최악의 응답시간을 알 수 있습니다.
4) 평균 대기시간이 FIFO와 SJF보다 적습니다. 단점 1) 성능은 규정 시간량의 길이에 따라 달라지므로 작업이 비슷한 길이가 좋은데, 너무 길면 FIFO로 변하고 짧으면 문맥 교환(Context Switching) 비용이 증가합니다.
2) 하드웨어적 타이머가 필요합니다.
3) 미완성 작업은 규정 시간량(시간 할당량)을 마친 후 프로세서를 기다리니까 평균 처리 시간이 높습니다.
우선순위 스케줄링
Priority Scheduling
각 프로세스에 우선순위 지정 – 우선순위를 부여하는 것
각 Process에 우선순위가 부여되어 있으면 cpu는 가장 우선순위가 높은 프로세스를 실행하게 된다.
물론 우선순위 표현할 때 높은 정수를 높게 하든, 낮은 점수를 높게 하든 설정할 수 있는데 낮은 정수가 더 높은 우선순위 나타내는 것이 일반적이다.
선점, 비선점 둘다 가능하다.
SJF는 우선순위 스케줄링의 일종이다. burst 길어지면 우선순위 낮아지고, burst 짧아지면 우선순위 높아진다.
우선순위 스케줄링 문제점 – Starvation(기아) 현상 일어날 수 있다. 우선순위가 5인 c가 없는데 B(3)인 것 먼저 실행해서 대기. 또 더 높은 우선순위 가진 process 들어와서 무한정 대기하는 현상 낮은 우선순위 가진 process가 실행되지 않는 문제
기아문제 해결하기 위한 것 → 노화 방법 (Aging) process 오래 기다리면 기다릴 수록 우선순위를 점점 더 높여주는 방법
어떤 프로세스가 cpu를 한번 받으면 물론 더 높은 우선순위 가진 process가 와서 뺏을 수 있겠지만 이렇게 되는 경우에, 너무 하나의 process가 cpu 시간 많이 쓰게 되어 사람들이 터미널 연결에서 사용하는 온라인 시스템에서는 FCFS, SJF 들이 적당하지 않다. → 개발된 방법이 round robin
Round Robin
돌아가면서 한번씩 하는것을 Round Robin 방식이다.
각 프로세스한테 cpu 시간을 쪼개서 process들한테 조그만 time quantum을 주게 되는 것
어떤 프로세스가 cpu를 자발적으로 내놓지 않더라도 시간이 지나면 강제로 뺏어서 다음 얘한테 cpu를 나눠주는 방식을 round robin 방식이라고 한다.
ex) 레디큐에 n개 process, 타임 퀀텀 q 모든 프로세스는 cpu 타임의 1/n 만큼 받는다. 1/n씩 받을 때 단위가 q time 만큼 받게 된다. 최대 기다리는 것 (n-1)q – 이 이상을 가지지 않는다. time 퀀텀 지나고 나면 cpu는 인터럽트걸 게 되고 다음 프로세스로 cpu를 넘겨주게 된다. time 퀀텀이 아주 크다면 FCFS 방식과 똑같이 된다. 아주 작으면 빠르게 CPU switch 되긴 되서 좋긴한데 context switch 많이 일어난다. (문맥 교환하는데 걸리는 시간 많이 걸림. 오버헤드가 커지게 된다.)
온라인 상황에서는 turn around 중요한 것이 아니라 얼마나 반응이 빨리 나오냐가 중요하기 때문에 RR 방식은 오라인 방식에 적합한 방식이다.
모든 작업이 끝나서 걸린 시간을 전체적으로 평균하게 되면 turn around 평균은 SJF 보다 크게 되고 response보다 작아진다.
퀀텀 적게 할 수록 → context switch 횟수↑, 낭비하는 시간↑
80%의 cpu burst가 time quantum 보다 더 작을 경우 turn around 빨라진다.
Multilevel Queue
우리가 레디큐를 여러개를 둬서 R1은 foreground 작업, R2는 background job을 집어 넣는 방식을 다단계 큐 방식 foreground – interactive 한 작업 (응답시간 중요함) – Round Robin 방식 background – background 작업 (turn around 중요함) – FSFJ, SJF
큐를 여러개를 두고 작업을 성격에 맞게 큐에 집어넣고 그 큐마다 각각의 스케줄링 알고리즘 돌리는 방법을 다단계 큐라고 한다.
큐간의 작업이 어떤것에 한 번 들어가면 옮길 수 없다. 다른 큐로 옮길 수 있으면 다단계 feedback queue
큐가 여러개가 있다면 큐들 사이에 스케줄링 어떻게 하나? FIXED priority scheduling ex) Foreground 작업이 더 중요하니까 R1이 비어있을 때만 R2 작업 수행 → R2에 있는 작업은 R1에 있는 작업 때문에 무한정 기다리는 기아 현상이 생길 수 있다. Time Slice (비율 나누는 방법) ex) R1 : 80, R2 : 20 – 기아현상 어느정도 해소 , 큐간의 스케줄링 알고리즘 고려해야 될 상황
MultiLevel Feedback Queue
레디큐를 여러개 두고 큐간의 작업이 이동할 수 있도록 허용하는 가장 일반적인 스케줄링 기법
cpu 스케줄링에서 가장 일반적인 형태 interactive job은 위에서 놀고 cpu 많이 쓰는 batch job 같은 경우는 떨어져서 FCFS 가게 된다. 너무 오래 기다렸다고 하면 승급시켜주는 aging 기법 적용
다단계 피드백 큐 고려사항
큐가 몇개인가 각 큐의 스케줄링 알고리즘 생각해야 함 언제 process를 업그레이드 시키느냐 언제 process를 강등시켜야 되나 프로세스가 새로 들어왔을 때, 어디 나갔다가 다시 돌아올 때 어디다 두는지 정책
Thread Scheduling
사용자 레벨 스레드는 스레드 라이브러리가 있어서 라이브러리가 스레드 스케줄링 한다.
커널 레벨 스레드 선택하는 것은 OS가 어떤 커널 레벨 스레드를 다음에 할 건가 선택하는 것이다.
사용자 레벨에 스레드를 스케줄링 할 때, process contention scope 라고 한다. 경쟁하는 영역이 하나의 프로세스다.
커널 레벨에서 스레드를 선택하는 것은 system contention scope 라고 이야기한다. 경쟁하는 영역이 시스템 전체이다.
Multicore Processor Scheduling – 다중처리기
Homogeneous Processor : 프로세스가 모두 동등하다고 생각한다.
비대칭적 다중 처리기 처리기가 c1, c2, c3 있을 때 c1 만 레디큐 관리한다. c2, c3는 레디큐에서 작업을 가져오려면 c1에 요청해야 한다. 레디큐를 한놈만 건드리면 비대칭적 다중 처리
대칭적 다중처리기 c1, c2, c3 모두 다 같은 권리 가지고 있다면 대칭적 다중처리기 일반적으로 가장 많이 사용한다. c1, c2, c3 다중처리기들이 공유데이터 동시접근하게 되면 공유데이터가 inconsistency 상태 빠질 수 있으므로 lock 을 이용해서 ready 큐 작업이 consistency 상태(일관적인 상태) 로 유지되도록 해야 된다.
Processor affinity (친화성) 돌아가는 프로세스가 있다면 process 들이 자기가 좋아하는 cpu를 설정할 수 있다. soft affinity – 시스템이 프로세스 원하는 cpu를 지정해주는데 사정 안되면 보장을 못하는 경우 hard affinity – cpu 세 개 있을 때 p1이 c1,c2 좋아한다고 하면 항상 c1, c2 한테 p1 지정하는 것
NUMA and CPU Schedulling
c1 보다 c2가 m2 에 더 빨리 접근할 수 있다. (NUMA 현상) → PROCESS AFFINITY 발생
멀티 프로세서 스케줄링 – load balancing
어떤 cpu는 놀고 있고 어떤 cpu는 작업이 많이 대기하고 있는 것을 방지하기 위해 load balancing 고려
load balancing 할려면 시스템이 부하를 주기적으로 체크를 한다.
강제 이동 : cpu1에 작업이 너무 많은데 cpu2 놀 고 있다면 cpu1 작업을 cpu2로 강제 이전하면 push migration
작업 당겨 오는 것 : cpu2가 할 작업이 없어 자발적으로 cpu1 작업 가져와서 실행한다면 pull migration
Multicore Processor
한 때 많이 사용했는데 점점 줄어들어 요즘은 multicore cpu를 사용하는 경우 많다. 하나의 cpu안에 여러개의 core를 주는 것. 메모리는 core 가 같이 공유 한개의 칩으로 구성 – 전력 ↓, 속도 ↑
1개의 core 가 있다면 여러개의 스레드 돌리는 것 일반적이다. 왜? core 가 메모리를 접근을 하게 되면 메모리에서 데이터를 읽어와서 레지스터에 갖고와서 연산을 하게 될텐데 cpu가 메모리를 읽어라 하고 명령 내리고 메모리에서 부터 데이터가 레지스터에 올라와서 ready 될 때 까지 시간이 걸린다. cpu는 상당히 빠른 장치고 메모리 접근시간보다 훨씬 더 빠르게 일을 할 수 있기 때문에 메모리에 있는 내용이 레지스터에 올라오는 시간동안에 core 는 놀고 있게 되는 것이다. 메모리 stall
computing, memory 읽음 , computing 반복 → memory stall cycle 이 많아서 core 노는 시간 커짐
core thread 2개 돌리면, memory 읽을 때 core를 다른 스레드한테 줌
core를 thread에 스위칭하면서 실행 → memory stall cycle 동안에 core 가 일하므로 속도 훨씬 빨라짐
하나의 core에 여러개 스레드 돌리는 것 일반적
[09. 스케줄링 알고리즘과 우선순위]
실행중인 모든 프로세스들에게 골고루 cpu를 할당하는 일이 필요하고, 그 일은 멀티프로세스를 지원하는 운영체제에서 담당하는 일이다
운영체제 일부분에 해당하는 스케줄러가 담당하는 일이다
Crocus
반응형
스케줄링 알고리즘 선택 기준
스케줄링 알고리즘을 선택하기 위해서는 몇가지 특성을 고려하여 선택해야 한다.
프로세서 사용률 :: 프로세서를 항상 실행 상태로 유지하여 유휴 상태(CPU가 쉬는 시간)이 되지 않도록 해야한다.
따라서 이때는 입출력 중심 작업 보다는 프로세서 중심 작업을 실행한다.
처리율 :: 단위시간당 완료하는 작업 수가 많도록 짧은 작업을 우선 처리하거나 인터럽트가 없도록 작업을 실행한다.
반환시간 :: 작업이 메모리에 들어가기까지 걸린 시간, Ready Queue에 머무는 시간, 실행 시간, I/O 시간 등 작업을 완료하는데 걸리는 시간을 최소화 시킨다. (끝난시간 – 도착시간)
대기시간 :: Ready Queue에서 기다리는 시간을 최소화 시킨다. (시작시간 – 도착시간)
반응시간 :: 작업을 요청한 시간부터 반응을 시작하는 시간까지의 간격을 의미한다. 대화형 시스템에서 중요하다.
반환시간 :: 끝난시간 – 도착시간
스케줄링 알고리즘
비선점 방법
선입 선처리 스케줄링(FCFS, First Come First Served or FIFO)
선입선처리 스케줄링은 비선점 방법이며 프로세서 스케줄링 알고리즘 중 가장 간단하다.
프로세서를 요청하는 순서대로 프로세서를 할당해준다. 이때 구현은 Queue로 하며 FIFO 형태를 이룬다.
장점
스케줄링의 구현이 쉽다.
Ready Queue에 있는 모든 프로세스가 실행될 수 있으므로 Starvation이 없다.
프로세서가 지속적으로 프로세스를 처리하므로 처리율이 높다.
단점
비선점식이라 대화식 프로세스에는 부적합하다.
장기 실행 프로세스가 단기 실행 프로세스를 모두 지연시켜 평균 대기시간이 길어지게 된다.(최악의 대기시간)
프로세스 도착 시간 실행 시간 P1 0 10 P2 1 20 P3 2 25 P4 3 14 P5 4 18
이 상황에서는 아래 그림으로 다음과 같이 나타낼 수 있다.
대기 시간
P1 :: 0
P2 :: 10 – 1 = 9
P3 :: 30 – 2 = 28
P4 :: 55 – 3 = 52
P5 :: 69 – 4 = 65
평균 대기시간 = (0 + 9 + 28 + 52 + 65) / 5 = 30.8
반환 시간
P1 :: 10 – 0 = 10
P2 :: 30 – 1= 29
P3 :: 55 – 2 = 53
P4 :: 69 – 3 = 66
P5 :: 87 – 4 = 83
평균 반환시간 :: (10 + 29 + 53 + 66 + 83) / 5 = 48.2
최소작업 우선 스케줄링(SJF, Shortest Job First)
최소작업 우선 스케줄링은 각 작업의 프로세서 실행 시간을 이용하여 프로세서가 사용 가능 할 때 실행시간이 가장 짧은 프로세스부터 자원을 할당해주는 방식이다.
즉 위의 FCFS의 방법과는 같지만 실행 시간이 작은 순서대로 우선순위 큐를 이용한다고 생각하면 된다.
(우선순위 큐 스케줄링은 따로 있다. SJF는 특이한 상황의 우선순위 큐 스케줄링이라 보면 된다.)
장점
항상 실행 시간이 짧은 작업을 가장 먼저 실행하므로 평균 대기시간이 가장 짧다
단점
초기의 긴 작업이 짧은 작업들이 끝날 때까지 기다려야하기에 Starvation 현상이 일어난다.
기본적으로 짧은 작업이 항상 먼저 시작되기에 불공평하다.
실행시간을 예측하기 어렵다.
프로세스 도착 시간 실행 시간 P1 0 10 P2 1 20 P3 2 25 P4 3 14 P5 4 18
대기 시간 P1 :: 0 P2 :: 42 – 1 = 41 P3 :: 62 – 2 = 60 P4 :: 10 – 3 = 7 P5 :: 24 – 4 = 20
평균 대기시간 = (0 + 41 + 60 + 7 + 20) / 5 = 25
반환 시간 P1 :: 10 – 0 = 10 P2 :: 62 – 1= 61 P3 :: 87 – 2 = 85 P4 :: 24 – 3 = 21 P5 :: 42 – 4 = 38
평균 반환시간 :: (10 + 61 + 85 + 21 + 38) / 5 = 43
HRN 스케줄링
SJF 방식에서 짧은 실행시간을 가진 것들만 프로세서를 차지하는 것을 어느정도 보완하고자 만들었다. 대기 시간과 실행 시간을 혼합하여 어느 작업을 CPU를 사용할 지 결정하는 방법이다.
이때 실행시간이 분모이므로 실행시간이 낮을수록 우선순위를 높게 받는다.
그리고 대기시간이 길수록 우선순위가 높아진다.
장점 자원을 효율적으로 활용할 수 있다. Starvation 상태가 발생하지 않는다.
단점 잦은 context switching으로 인해 오버헤드가 높을 수 있다.
비선점 & 선점 방법
우선순위 스케줄링(Priority)
우선순위 스케줄링은 프로세스가 Ready Queue에 도착하면 우선순위를 비교하여 우선순위가 가장 높은 프로세스에 프로세서(CPU)를 할당하는 방식이다.
장점 각 프로세스의 상대적 중요도를 명시 할 수 있다. 실시간 시스템에 유리하다
단점 높은 우선순위 프로세스가 계속 오면 우선순위가 낮은 프로세스는 Starvation 현상을 겪을 수 있다.
우선순위 정하는 방법
우선순위(P)는 프로세서 버스트 시간의 역이다. 즉, P = 1/τ이다. 이때 프로세서 버스트 시간이라는 것은 프로세스 실행 시간과 동치이다. 즉, 실행 시간이 클수록 우선순위가 낮게된다. ‘ 우선순위는 외부, 내부적으로 정의도 가능하다.
내부적 우선순위로는 제한시간, 사용파일 수, 평균 프로세서 버스트에 대한 평균 입출력 버스트 비율 등등이 있고 외부적 우선순위로는 프로세스의 중요성, 사용료를 많이 낸 사용자, 정책적인 요인 등등이 있다.
우선순위 스케줄링은 선점 또는 비선점 방식이 가능한데
선점 우선순위 스케줄링은 새로 도착한 프로세스의 우선순위가 현재 실행중인 프로세스의 우선순위보다 높으면 프로세서(CPU)를 획득한다.
비선점 우선순위 스케줄링은 실행중인 것과 무관하게 우선순위가 높다면 큐의 제일 앞에 넣어준다.
프로세스 도착 시간 실행 시간 우선순위 P1 0 10 3 P2 1 28 2 P3 2 6 4 P4 3 14 1 P5 4 14 2
대기 시간 P1 :: 8 – 0 – 2 = 6 P2 :: 16 – 1 = 15 P3 :: 2 – 2 = 0 P4 :: 58 – 3 = 55 P5 :: 44 – 4 = 40
평균 대기시간 = (6 + 15 + 0 + 55 + 40) / 5 = 23.2
반환 시간 P1 :: 16 – 0 = 16 P2 :: 44 – 1= 43 P3 :: 8 – 2 = 6 P4 :: 62 – 3 = 59 P5 :: 58 – 4 = 54
평균 반환시간 :: (16 + 43 + 6 + 59 + 54) / 5 = 35.6
대기 시간 P1 :: 0 P2 :: 16 – 1 = 15 P3 :: 10 – 2 = 8 P4 :: 58 – 3 = 55 P5 :: 44 – 4 = 40
평균 대기시간 = (0 + 15 + 8 + 55 + 40) / 5 = 23.6
반환 시간 P1 :: 10 – 0 = 10 P2 :: 44 – 1= 43 P3 :: 16 – 2 = 14 P4 :: 62 – 3 = 59 P5 :: 58 – 4 = 54
평균 반환시간 :: (10 + 43 + 14 + 59 + 54) / 5 = 36
에이징
우선순위 스케줄링 알고리즘에서 가장 큰 허점은 우선순위가 낮은 프로세스는 우선순위가 높은 프로세스가 계속 들어오면 영원히 스케줄러에 선택받지 못하게 된다. 즉, 기아 상태(Starvation)가 된다.
따라서 에이징이라는 기법을 이용하여 오래 대기하는 프로세스가 우선순위를 점진적으로 증가시켜주는 방법을 이용한다.
선점형 스케줄링
라운드 로빈 스케줄링(Round Robin)
라운드 로빈 스케줄링은 프로세스가 프로세서에서 동작할 수 있는 시간을 할당해준다.
이때 라운드 로빈 큐는 원형 큐로 설계되어있어 프로세스가 시간을 다 쓰면 OS가 인터럽트를 걸어 현재 PCB가 큐의 가장 뒤로 가는 방식이다.
장점 모든 프로세스가 공정하게 시간을 할당받기에 starvation이 발생하지 않는다. 프로세스의 최악의 응답시간을 아는데 용이하다
단점 하드웨어 타이머가 필요하다 작업 시간 할당을 너무 짧게 하면 Context Switching이 자주 일어나 오버헤드가 일어난다.
프로세스 도착 시간 실행 시간 P1 0 10 P2 1 28 P3 2 6 P4 3 4 P5 4 14
CPU 점유 시간을 5로 제한했을 때
대기 시간 P1 :: 24 – 5*1 – 0 = 19 P2 :: 49 – 5*3 – 1 = 33 P3 :: 34 – 5-1 – 2 = 27 P4 :: 15 – 5*0 – 3 = 12 P5 :: 45 – 5*2 – 4 = 31
평균 대기시간 = (19 + 33 + 27 + 12 + 31) / 5 = 24.4
반환 시간 P1 :: 29 – 0 = 29 P2 :: 62 – 1= 61 P3 :: 35 – 2 = 33 P4 :: 19 – 3 = 16 P5 :: 49 – 4 = 45
평균 반환시간 :: (29 + 61 + 33 + 16 + 45) / 5 = 36.8
다단계 큐 스케줄링(MLQ, MultiLevel Queue)
다단계 큐 스케줄링은 준비 상태 큐를 여러 종류별, 단계별로 분할해두고 자신만의 독자적인 스케줄링 구현이 가능하다. (즉, 시스템 프로세스는 우선순위 큐로, 학생 프로세스는 round-robin으로 등등..)
각 큐는 절대적인 우선순위를 가지며(여기선 시스템 프로세스가 우선순위가 가장 높다) 우선순위 높은 큐가 모두 비어있기 전에는 낮은 우선순위 큐에 있는 프로세스를 실행 할 수 없다.
장점 응답이 빠르다.
단점 여러 준비 큐와 스케줄링 알고리즘 때문에 추가 오버헤드가 발생 우선순위가 낮은 큐의 프로세스는 Starvation 현상이 일어 날 수 있다.
다단계 피드백 큐 스케줄링(MLFQ, MultiLevel Feedback Queue)
다단계 피드백 큐 스케줄링은 다단계 큐 스케줄링에서 계속해서 프로세서를 선점하지 못하는 프로세스에 대해 큐의 이동을 시켜주는 방식을 이용한다. 즉, 다단계 큐 방식에서 오래 대기한 프로세스가 높은 레벨의 대기 큐로 이동한다. 혹은 프로세서 버스트 시간이 짧은 프로세스에 높은 우선순위를 주어 일직 종료시키거나 시간이 너무 오래 걸리면 낮은 우선순위로 변경시킨다.
장점 매우 유연하여 스케줄러를 특정 시스템에 맞게 구현 가능하다. 자동으로 입출력 중심, 프로세서 중심 프로세스를 구분한다. 적응성이 높아 프로세스의 사전 정보 없이도 최소작업 우선 스케줄링의 효과를 보여준다.
단점 설계와 구현이 매우 복잡하다.
짚고 넘어가기
1. 스케쥴링의 목적은 I/O 대기, Memory stall처럼 CPU 유휴 시간을 최소화 시켜 CPU 자원 활용을 극대화 하기 위함이다. *memory stall : 프로세서가 메모리에 접근할 때, 데이터가 사용 가능할 때까지 많은 시간이 소모된다.* (EX : 컨텍스트 스위칭)
2. CPU 스케줄링의 실제 대상은 커널 스레드이다.(우리는 항상 프로세스라고 배웠지만 실제로는 프로세스를 담당하는 커널 스레드이다.) (참고 : http://drayong.tistory.com/13)
3. 우선순위 스케줄링 알고리즘에서는 에이징을 이용하여 Starvation을 방지하고, 우선순위 스케줄링은 선점, 비선점이 존재한다. -> Priority 스케줄링 알고리즘은 우선순위 스케줄링은 선점 또는 비선점 방식이 가능한데 선점 우선순위 스케줄링은 새로 도착한 프로세스의 우선순위가 현재 실행중인 프로세스의 우선순위보다 높으면 프로세서(CPU)를 획득한다. 비선점 우선순위 스케줄링은 실행중인 것과 무관하게 우선순위가 높다면 큐의 제일 앞에 넣어준다.
이 게시물의 전체적인 내용은 그림으로 배우는 구조와 원리 운영체제를 기반으로 작성했습니다.
문제가 된다면 삭제 조치 하겠습니다.
링크 : https://book.naver.com/bookdb/book_detail.nhn?bid=10786045
반응형
CPU 스케줄링 (3)
0. 스케줄링 개요
Priority(우선순위) 스케줄링은 말 그대로 우선순위 순서대로 스케줄링을 진행하는 것이다. 우선순위는 정수값으로 주어지며 일반적으로 낮은 숫자가 높은 우선순위를 의미한다.
1. 우선순위 선정
우선순위는 프로세스 내부적인 요인과 외부적인 요인에 의해 결정된다.
내부 요인 : 수행시간(SJF처럼), 메모리/IO/CPU 소비량(적은것 먼저)
외부 요인 : 유료 서버 컴퓨터의 경우 높은 등급의 사용자의 프로세스를 높혀주는 등
2. SJF처럼 선점, 비선점 모두 가능하다.
중간에 더 우선순위가 높은 프로세스가 입력되면 프로세스를 밀어내고 높은 우선순위의 프로세스가 먼저 실행된다면 선점, 그렇지 하지 않고 우선순위가 높은 프로세스가 입력되어도 프로세스를 밀어내지 않으면 비선점 스케줄링이다.
3. 우선순위 스케줄링의 문제점
Starvation (기아) 상태 : 우선순위가 낮은 프로세스가 ReadyQueue에서 대기하고 있는데 뒤에서 계속 우선순위가 높은 프로세스가 지속적으로 큐에 삽입되면 우선순위가 낮은 프로세스는 영원히 기다려야 할 수도 있다. 이런 상태를 기아상태라고 한다.
이런 상태를 기아상태라고 한다. Aging (에이징) : Starvation 상태의 해결법이다. 쉽게 말해서 프로세스가 나이를 먹는 것이다. 오래된 프로세스일 수록 우선순위가 낮더라도 오래 기다렸으면 우선순위를 조금씩 올려주는 방법으로 우선순위 프로세스를 적용하는 경우 많이 사용된다.
4. 소스코드
1) PriorityJob 클래스
package jobs; /** * @author : Hyunwoong * @when : 2020-02-04 오후 8:34 * @homepage : https://github.com/gusdnd852 */ public class PriorityJob { public int PID; public int remain; public int priority; public PriorityJob(int PID, int remain, int priority) { this.PID = PID; this.remain = remain; this.priority = priority; } @Override public String toString() { return “P” + String.valueOf(PID) + “(” + priority + “)”; } }
2) Priority 스케줄러 클래스
package schedulers; import jobs.PriorityJob; import java.util.Comparator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; /** * @author : Hyunwoong * @when : 2020-02-04 오후 8:30 * @homepage : https://github.com/gusdnd852 */ public class PriorityScheduler { private List
readyQueue = new CopyOnWriteArrayList<>(); private ExecutorService runningThread = Executors.newSingleThreadExecutor(); void insert(PriorityJob job) { readyQueue.add(job); readyQueue.sort(Comparator.comparingInt(j -> j.priority)); // 우선순위를 기준으로 정렬 } void interval(int n, int m) { for (int i = n; i < m + n; i++) { sleep(990); // 오버헤드 고려해서 10msec 빠르게 insert(new PriorityJob(i, 1, 5)); if (i + 1 == m + n) System.exit(0); } } void start() { runningThread.execute(() -> { while (readyQueue.size() != 0) { for (PriorityJob job : readyQueue) { while (job.remain > 0) { if (!job.equals(readyQueue.get(0))) break; log(job); sleep(1000); job.remain–; if (job.remain == 0) readyQueue.removeIf(j -> j.remain == 0); } } } runningThread.shutdownNow(); System.exit(0); }); } public static void main(String[] args) { PriorityScheduler scheduler = new PriorityScheduler(); scheduler.insert(new PriorityJob(1, 1, 30)); scheduler.insert(new PriorityJob(2, 1, 5)); scheduler.insert(new PriorityJob(3, 1, 5)); scheduler.start(); scheduler.interval(4, 55); } void log(PriorityJob job) { System.out.println(job + ” is running ” + readyQueue); } static void sleep(int msec) { try { TimeUnit.MILLISECONDS.sleep(msec); } catch (InterruptedException e) { e.printStackTrace(); } } } 출력 : P2(5) is running [P2(5), P3(5), P1(30)] P3(5) is running [P3(5), P4(5), P1(30)] P4(5) is running [P4(5), P5(5), P1(30)] P5(5) is running [P5(5), P6(5), P1(30)] P6(5) is running [P6(5), P7(5), P1(30)] P7(5) is running [P7(5), P8(5), P1(30)] P8(5) is running [P8(5), P9(5), P1(30)] P9(5) is running [P9(5), P10(5), P1(30)] P10(5) is running [P10(5), P11(5), P1(30)] P11(5) is running [P11(5), P12(5), P1(30)] P12(5) is running [P12(5), P13(5), P1(30)] P13(5) is running [P13(5), P14(5), P1(30)] P14(5) is running [P14(5), P15(5), P1(30)] P15(5) is running [P15(5), P16(5), P1(30)] P16(5) is running [P16(5), P17(5), P1(30)] P17(5) is running [P17(5), P18(5), P1(30)] P18(5) is running [P18(5), P19(5), P1(30)] P19(5) is running [P19(5), P20(5), P1(30)] P20(5) is running [P20(5), P21(5), P1(30)] P21(5) is running [P21(5), P22(5), P1(30)] P22(5) is running [P22(5), P23(5), P1(30)] P23(5) is running [P23(5), P24(5), P1(30)] P24(5) is running [P24(5), P25(5), P1(30)] P25(5) is running [P25(5), P26(5), P1(30)] P26(5) is running [P26(5), P27(5), P1(30)] P27(5) is running [P27(5), P28(5), P1(30)] P28(5) is running [P28(5), P29(5), P1(30)] P29(5) is running [P29(5), P30(5), P1(30)] P30(5) is running [P30(5), P31(5), P1(30)] P31(5) is running [P31(5), P32(5), P1(30)] P32(5) is running [P32(5), P33(5), P1(30)] P33(5) is running [P33(5), P34(5), P1(30)] P34(5) is running [P34(5), P35(5), P1(30)] P35(5) is running [P35(5), P36(5), P1(30)] P36(5) is running [P36(5), P37(5), P1(30)] P37(5) is running [P37(5), P38(5), P1(30)] P38(5) is running [P38(5), P39(5), P1(30)] P39(5) is running [P39(5), P40(5), P1(30)] P40(5) is running [P40(5), P41(5), P1(30)] P41(5) is running [P41(5), P42(5), P1(30)] P42(5) is running [P42(5), P43(5), P1(30)] P43(5) is running [P43(5), P44(5), P1(30)] P44(5) is running [P44(5), P45(5), P1(30)] P45(5) is running [P45(5), P46(5), P1(30)] P46(5) is running [P46(5), P47(5), P1(30)] P47(5) is running [P47(5), P48(5), P1(30)] P48(5) is running [P48(5), P49(5), P1(30)] P49(5) is running [P49(5), P50(5), P1(30)] P50(5) is running [P50(5), P51(5), P1(30)] P51(5) is running [P51(5), P52(5), P1(30)] P52(5) is running [P52(5), P53(5), P1(30)] P53(5) is running [P53(5), P54(5), P1(30)] P54(5) is running [P54(5), P55(5), P1(30)] P55(5) is running [P55(5), P56(5), P1(30)] P56(5) is running [P56(5), P57(5), P1(30)] // Starvation 발생. P1이 영원히 끝나지 않음
3) Aging 스케줄러 클래스
package schedulers; import jobs.PriorityJob; import java.util.Comparator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; /** * @author : Hyunwoong * @when : 2020-02-04 오후 8:30 * @homepage : https://github.com/gusdnd852 */ public class AgingScheduler { private List
readyQueue = new CopyOnWriteArrayList<>(); private ExecutorService runningThread = Executors.newSingleThreadExecutor(); void insert(PriorityJob job) { readyQueue.add(job); readyQueue.sort(Comparator.comparingInt(j -> j.priority)); // 우선순위를 기준으로 정렬 } void interval(int n, int m) { for (int i = n; i < m + n; i++) { sleep(990); // 오버헤드 고려해서 10msec 빠르게 insert(new PriorityJob(i, 1, 5)); if (i + 1 == m + n) System.exit(0); } } void start() { runningThread.execute(() -> { while (readyQueue.size() != 0) { for (PriorityJob job : readyQueue) { int average = 0; for (PriorityJob j : readyQueue) average += j.PID; average /= readyQueue.size(); if (job.PID < average) { job.priority--; // Aging 수행 // PID가 평균보다 낮으면 (오래 되었으면) // 우선순위를 깎아서 개선해줌. } while (job.remain > 0) { if (!job.equals(readyQueue.get(0))) break; log(job); sleep(1000); job.remain–; if (job.remain == 0) readyQueue.removeIf(j -> j.remain == 0); } } } runningThread.shutdownNow(); System.exit(0); }); } public static void main(String[] args) { AgingScheduler scheduler = new AgingScheduler(); scheduler.insert(new PriorityJob(1, 1, 30)); scheduler.insert(new PriorityJob(2, 1, 5)); scheduler.insert(new PriorityJob(3, 1, 5)); scheduler.start(); scheduler.interval(4, 55); } void log(PriorityJob job) { System.out.println(job + ” is running ” + readyQueue); } static void sleep(int msec) { try { TimeUnit.MILLISECONDS.sleep(msec); } catch (InterruptedException e) { e.printStackTrace(); } } } 출력 : P2(5) is running [P2(5), P3(5), P1(30)] P3(5) is running [P3(5), P4(5), P1(30)] P4(5) is running [P4(5), P5(5), P1(29)] P5(5) is running [P5(5), P6(5), P1(29)] P6(5) is running [P6(5), P7(5), P1(28)] P7(5) is running [P7(5), P8(5), P1(28)] P8(5) is running [P8(5), P9(5), P1(27)] P9(5) is running [P9(5), P10(5), P1(27)] P10(5) is running [P10(5), P11(5), P1(26)] P11(5) is running [P11(5), P12(5), P1(26)] P12(5) is running [P12(5), P13(5), P1(25)] P13(5) is running [P13(5), P14(5), P1(25)] P14(5) is running [P14(5), P15(5), P1(24)] P15(5) is running [P15(5), P16(5), P1(24)] P16(5) is running [P16(5), P17(5), P1(23)] P17(5) is running [P17(5), P18(5), P1(23)] P18(5) is running [P18(5), P19(5), P1(22)] P19(5) is running [P19(5), P20(5), P1(22)] P20(5) is running [P20(5), P21(5), P1(21)] P21(5) is running [P21(5), P22(5), P1(21)] P22(5) is running [P22(5), P23(5), P1(20)] P23(5) is running [P23(5), P24(5), P1(20)] P24(5) is running [P24(5), P25(5), P1(19)] P25(5) is running [P25(5), P26(5), P1(19)] P26(5) is running [P26(5), P27(5), P1(18)] P27(5) is running [P27(5), P28(5), P1(18)] P28(5) is running [P28(5), P29(5), P1(17)] P29(5) is running [P29(5), P30(5), P1(17)] P30(5) is running [P30(5), P31(5), P1(16)] P31(5) is running [P31(5), P32(5), P1(16)] P32(5) is running [P32(5), P33(5), P1(15)] P33(5) is running [P33(5), P34(5), P1(15)] P34(5) is running [P34(5), P35(5), P1(14)] P35(5) is running [P35(5), P36(5), P1(14)] P36(5) is running [P36(5), P37(5), P1(13)] P37(5) is running [P37(5), P38(5), P1(13)] P38(5) is running [P38(5), P39(5), P1(12)] P39(5) is running [P39(5), P40(5), P1(12)] P40(5) is running [P40(5), P41(5), P1(11)] P41(5) is running [P41(5), P42(5), P1(11)] P42(5) is running [P42(5), P43(5), P1(10)] P43(5) is running [P43(5), P44(5), P1(10)] P44(5) is running [P44(5), P45(5), P1(9)] P45(5) is running [P45(5), P46(5), P1(9)] P46(5) is running [P46(5), P47(5), P1(8)] P47(5) is running [P47(5), P48(5), P1(8)] P48(5) is running [P48(5), P49(5), P1(7)] P49(5) is running [P49(5), P50(5), P1(7)] P50(5) is running [P50(5), P51(5), P1(6)] P51(5) is running [P51(5), P52(5), P1(6)] P52(5) is running [P52(5), P53(5), P1(5)] P53(5) is running [P53(5), P1(5), P54(5)] P1(4) is running [P1(4), P54(5), P55(5)] P54(4) is running [P54(4), P55(5), P56(5)] P55(4) is running [P55(4), P56(5), P57(5)] // Starvation 해결. P54가 수행되어야 할 시간에 P1이 실행되어 끝났음.
6. Reference
우선순위 스케줄링
여기서는 숫자가 작을수록 우선순위가 높음. 반대로 표현하는 경우도 있음
자원이 부족한 상태에서 우선순위가 높은 프로세스가 계속 들어와서 우선순위가 낮은 프로세스가 계속 수행되지 못하는 현상
#3 – 2) 스케줄링 기법 및 종류와 Aging(에이징) 기법
※ 이 글을 작성하기 전에 본인은 이 분야의 전문성을 가진 전문가가 아님을 미리 밝힙니다. ※
#1. 선점형 기법과 비 선점형 기법
스케줄링은 크게 2가지 기법으로 나눌 수 있다.
1. 비선점형 스케줄링 기법
2. 선점형 스케줄링 기법
#1 – 2) 비선점형 스케줄링 기법
비선점형 스케줄링 기법이라는 것은, 이미 할당된 CPU를 다른 프로세스가 중간에 강제로 빼앗을 수 없는 기법을 비선점형 기법이라고 한다.
먼저 실행된 프로세스가 먼저 처리되기 때문에 공정한 처리가 가능하다고 볼 수 있으며, 일괄적인 처리 방식에는 적합하다.
하지만, “짧지만 중요한 작업이 길지만 중요하지 않은 작업에 밀려서 긴 시간동안 기다려야 하는 경우가 발생” 할 수도 있다.
#1 – 3) 선점형 스케줄링 기법
선점형 스케줄링 기법이라는 것은, 준비 상태(=Ready Queue)에 있는(실행을 대기하고 있는) 프로세스들 중에서 우선순위가
가장 높은 프로세스에게 먼저 CPU를 할당하는 기법이다.
즉 ! 우선순위에 따라서 실행중인 프로세스가 실행을 멈추고 다른 프로세스에게 CPU를 빼앗길 수 있는 기법이다.
#2. 비선점형 스케줄링 기법 종류
#1. FIFO(First In First Out) = FCFS(First Come First Serve)
– 먼저 도착한 프로세스가 먼저 CPU를 할당하는 방식이다.
– 공평성이 유지되지만, 중요한 작업이 중요치 않은 작업에 밀려서 늦게 처리되는 문제점이 발생할 수 있다.
– 또한, “Convoy Effect” 현상이 발생할 수 있다. 실행시간이 긴 프로세스가 먼저 도착하게 되면,
효율성이 떨어지는 현상이 발생한다.
#2. SJF(Shortest Job First)
– 준비상태에 누가 먼저 도착했는지와 상관없이, 실행시간(CPU Burst Time)이 가장 짧은 프로세스에게 CPU를 할당하는 방식.
– 짧은 작업들을 우선적으로 처리하다 보니, 평균 대기시간이 가장 적은 최적의 스케줄링 기법이다.
– 하지만 ! “Starvation(기아현상)” 이 발생할 수 있다. 실행시간이 상대적으로 긴 프로세스의 경우, 실행시간이 짧은 프로세스들
에게 밀리고 밀려서 거의 영원히 CPU를 할당받을 수 없게되는 현상이 발생한다.
#3. HRN / HRRN (Highest Response Ratio Next)
– SJF 기법에서 비교적 실행시간이 긴 프로세스가 가질 수 있는 불리함을 보완한 스케줄링 방식이다.
– “우선순위”를 계산해서 프로세스들에게 순서를 부여 하는 방식이다.
– “우선순위 = (대기시간 + 실행시간) / 실행시간” 을 통해서 계산되어진다.
– 위의 공식에서, “대기시간”이 길어질 수록, 더 큰 값을 가지게 되므로, “실행시간이 길다는 이유로, 실행시간이 짧은 프로세스에
게 밀려서 오랫동안 기다린 프로세스가 더 높은 우선순위를 가지게 만든다”.
– ex)
위와 같이 3개의 프로세스가 존재한다고 생각해보자.
SJF 기법에 의하면, 실행시간이 가장 긴, P2가 무조건 가장 마지막에 실행되어야 할 것이다.
하지만, HRRN 기법에 의해서 위의 프로세스들의 우선순위를 구해보면 다음과 같다.
P1 = (5 + 10) / 10 = 1.5
P2 = (20 + 20) / 20 = 2
P3 = (15 + 5) / 5 = 4
더 높은 값부터 차례대로 우선순위를 부여하게 되면, P3 – P2 – P1 순으로 실행되어 질 것이다.
P2의 입장에서 보면, P1보다 실행시간이 훨씬 길지만, P1보다 먼저 실행되는 것을 확인할 수 있다.
#4. 우선순위(Priority)
– 프로세스들에게 특정 우선순위를 부여하여서, 상대적으로 더 높은 우선순위를 가지는 프로세스를 대기상태의 가장 첫 번째에
넣는 방식이다.
– “비선점 스케줄링 우선순위 기법”은 실행되고 있는 프로세스는 제외하고, 대기상태에 있는 프로세스들 끼리 우선순위를
비교하게 되고, 우선순위가 가장 높은 프로세스를 대기 상태의 첫 번째로 배치하게 된다.
– 즉, 현재 실행되고 있는 프로세스가 끝난다면, 그 다음으로 우선순위가 가장 높은 프로세스가 진행되어 진다.
– 하지만 ! “Starvation(기아현상)” 이 발생할 수 있다. 상대적으로 높은 우선순위를 갖지 못하는 프로세스가 계속해서 높은
우선 순위를 갖지 못해서 거의 영원히 실행되지 못하는 현상이 발생한다.
#5. 기한부(Deadline)
– 프로세스가 사용할 수 있는 CPU의 시간을 정해주고, 그 시간 안에 프로세스를 완료하도록 하는 기법이다.
– 주어진 시간 내에 완료되지 못할 경우, 해당 프로세스는 제거되거나 처음부터 다시 실행되어야 하므로 부담이 매우 큰 기법이다.
– 시스템은 프로세스에게 정확한 시간을 할당해 주어야 하며, 사용자는 시스템이 요구한 프로세스에 대해서 정확한 정보를
제공해줘야 하는 기법이다.
#3. 선점형 스케줄링 기법
#1. RR(Round-Robin)
– 비선점 기법인 FIFO(FCFS)를 선점형 기법으로 변환한 스케줄링 기법이다.
– FIFO와 같이 먼저 들어온 프로세스가 먼저 CPU를 할당받게 되지만, 각 프로세스들은 할당된 시간만큼만 CPU를 사용할 수
있게 된다. 만약, 해당 시간내로 완료하지 못했다면, 대기 상태의 가장 마지막으로 들어가게 된다.
– 시분할 시스템을 위해서 고안된 기법이다.
– CPU 사용시간이 랜덤한 프로세스들이 섞여 있을 때 효율적인 기법이다.
– 응답시간이 매우 최적화 되어있는 공정한 스케쥴링 기법이다.
– 하지만 ! 프로세스에게 할당되는 CPU 시간이 너무 길다면, FIFO와 같아지는 현상이 발생하고, CPU시간이 너무 짧아진다면,
Context-Switching이 자주 일어나서 오버헤드가 발생할 가능성이 있다.
[ Context-Switching에서 오버헤드가 발생하는 이유 알아보기(Click) ]#2. SRT(Shortest Remaining Time)
– 비선점 기법인 SJF 스케쥴링 기법을 선점형 기법으로 변환한 스케줄링 기법이다.
– 현재 실행준인 프로세스의 남은 시간과 준비상태 대기열에 새로 도착한 프로세스의 실행시간을 비교하여 가장 짧은 실행 시간을
요구하는 프로세스에게 CPU를 할당하는 기법이다.
#3. MLQ(Multi Level Queue) (다단계 큐 스케줄링)
– 프로세스들을 특정 그룹으로 분리하여, 각 그룹마다 독자적인 Queue를 이용해서 스케줄링 하는 기법이다.
– “특정 그룹으로 분리” 한다 라는 것은, 여러 단계로 분할할 수가 있지만, 크게 본다면 사용자와 상호작용하는
전면작업(Foreground Task)와 그렇지 않은 후면작업(Background Task)로 분리할 수 있다.
(실제로, 이렇게 2가지로만 나눠서 사용하지는 않습니다. 프로세스의 특성 및 종류에 따라서 여러개로 나뉘어 집니다.)
– 전면작업은 상대적으로 우선순위가 더 높다고 판단하고, 후면작업은 상대적으로 덜 중요하다고 판단할 수 있다.
– 이 때, 전면작업 Queue에 들어 있는 프로세스들에 대해서는 Round-Robin과 같이 효율적이 빠르게 실행될 수 있는
기법을 사용하게 되고, 후면작업 Queue에 들어있는 프로세스들은 FIFO 기법으로 진행되어 진다.
– 중요도에 따라서 1차적으로 어떤 Qqueue에 저장할지 우선순위를 정하고, 두 번째로 각 Queue에서는 서로 다른 알고리즘
혹은 다른 스케줄링 기법들을 통해서 Queue에 저장된 프로세스들의 우선순위를 정하게 된다.
이러한 구조 때문에 프로세스의 우선순위 처리에 대한 효율성을 높일 수 있다.
– 하지만 ! 한번 특정 Queue에 들어가는 순간, 다른 Queue로 이동되거나 변경되는 것은 불가능하기 때문에 스케줄링에 대한
오버헤드가 낮다는 장점이 있는 반면, 유연하지 못하다는 단점이 존재한다.
– MLQ의 구조를 그림으로 간단하게 표현하면 다음과 같다.
#4. MLFQ(Multi Level Feedback Queue) (다단계 피드백 큐 스케줄링)
– 특정 그룹의 Queue에 들어간 프로세스가 다른 Queue로 이동하거나 변경이 불가능한 MLQ 기법을, 서로 다른 Queue로도
이동할 수 있도록 개선한 기법이다.
– MLQ 방식과 달리, 처음부터 특정 그룹으로 분리한 후, 적합한 Queue에 들어가는 방식이 아닌, 무조건 1차적으로는 “가장 중요
한 작업이라고 판단되는 프로세스들이 모이는 Queue”로 들어가게 된다.
– 위에서 들어간 Queue에서는 “Round-Robin”기법을 이용해서 스케줄링 되어지는데, 만약 이 때, 프로세스가 실행을 완료하지
못한다면 그 다음 Queue로 넘어가게 된다.
– 이 다음 Queue에서는 이전의 Queue에 비해서 할당시간을 2배 더 큰 값을 할당해준다.
– 위와 같은 방시긍로 프로세스가 주어진 Queue에서 모두 처리되지 못한다면, 가장 중요도가 낮다고 판단되는 Queue로
최종적으로 들어가게 되고, 이 Queue에서는 FIFO(FCFS) 기법으로 처리하게 된다.
– 즉 ! RoundRobin기법의 할당시간을 보고 우선순위를 예측하고 변경하면서 사용하는 기법이다.
– MLFQ의 구조를 그림으로 간단하게 나타내면 다음과 같다.
#5. 우선순위(Priority)
– 우선순위 기법에 대해서 이야기 하기 전에 ! 우선순위 기법은 위에서 “비선점형 스케줄링 기법” 이라고 이야기 했었다.
– 하지만 ! 우선순위 기법은 선점형으로도 사용이 가능하다.
– 비선점형 우선순위 기법에서는, 대기 상태에 있는 프로세스들간의 우선순위를 비교하였지만, 선점형 우선순위 기법에서는
현재 실행중인 프로세스까지 함께 비교하여서, 만약 현재 실행중인 프로세스보다 우선순위가 더 높은 프로세스가
대기열에 들어오게 된다면, 실행중인 프로세스를 멈추고 더 높은 우선순위인 프로세스를 진행하게 된다.
– 이 또한, 마찬가지로 우선순위가 상대적으로 낮은 프로세스가 거의 영원히 CPU를 할당받지 못하는 문제가 발생한다.
#4. Aging(에이징) 기법
– 에이징 기법은 시스템에서 특정 프로세스의 우선순위가 낮아서 무한정 기다리는 경우를 방지하기 위해서 기다린 시간에
비례해서 일정 시간이 지나면 우선순위를 한 단계식 높여주는 방법이다.
– “무한연기 or 기아상태를 예방” 하기 위한 기법이다.
– SJF 기법에서 상대적으로 실행시간이 긴 프로세스들이 거의 영원히 CPU를 할당받지 못하는 상황을 예방하기 위해서
Aging기법을 도입해 HRN(HRRN) 기법으로 사용하는 것.
– MLQ 기법에서 높은 우선순위를 먼저 처리 및 유연한 방법으로 처리하기 위해서 Aging 기법을 도입해 MLFQ 기법으로
사용하는 것.
키워드에 대한 정보 우선 순위 스케줄링
다음은 Bing에서 우선 순위 스케줄링 주제에 대한 검색 결과입니다. 필요한 경우 더 읽을 수 있습니다.
이 기사는 인터넷의 다양한 출처에서 편집되었습니다. 이 기사가 유용했기를 바랍니다. 이 기사가 유용하다고 생각되면 공유하십시오. 매우 감사합니다!
사람들이 주제에 대해 자주 검색하는 키워드 [시나공 정보처리] 1417100 주요 스케줄링 알고리즘
- 시나공
- 길벗
- 알앤디
- IT
- 자격증
- 컴퓨터
- 강의
- 토막강의
- 컴활
- 컴퓨터활용능력
- 워드
- 워드프로세서
- 정보처리
- 기사
- 산업기사
- 기능사
- 사무자동화
- 사무
- 정처기
- 1급
- 2급
- 필기
- 실기
- 엑셀
- 액세스
- java
- 언어
- 정기
- 상시
- 기출
- 시험
- c언어
YouTube에서 우선 순위 스케줄링 주제의 다른 동영상 보기
주제에 대한 기사를 시청해 주셔서 감사합니다 [시나공 정보처리] 1417100 주요 스케줄링 알고리즘 | 우선 순위 스케줄링, 이 기사가 유용하다고 생각되면 공유하십시오, 매우 감사합니다.
