백준 1671번 상어의 저녁식사.


문제 설명

 

 크기, 속도, 지능 모두 크거나 같으면  i -> j 가 먹을 수 있다.  =  "i 에서 j로 갈 수 있다" 

즉, 먹을 수 있는 간선들을 모두 만들면 이분 매칭 문제와 같다.

 

 주의할 점은 크기, 속도, 지능 모두 같으면 서로 잡아먹어서 0이 될 수도 있으므로

상어 한마리가 또다른 한마리만 먹을 수 있도록 설정했다.

 ex)  크기: 10 속도:10 지능:10 인 상어 2마리(i,j) 가 있을 때  i는 j를 잡아 먹을 수 있지만 j는 i를 잡아먹지 못하도록 설정했다.



문제 바로가기 : boj.kr/1671



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*

fun main(args: Array<String>) {
    data class Shark(val size:Int,val speed:Int,val intel:Int):Comparable<Shark>{
        override fun compareTo(other: Shark): Int {
            if(size==other.size&&speed==other.speed&&intel==other.intel)    return 0
            if(size>=other.size&&speed>=other.speed&&intel>=other.intel)    return 1
            return -1
        }
    }
    val br=BufferedReader(InputStreamReader(System.`in`))
    val list=ArrayList<Shark>()
    val n=br.readLine()!!.toInt()
    var visit=BooleanArray(n)
    val B=IntArray(n){-1}
    val adj=Array(n){ LinkedList<Int>() }
    repeat(n){
        val (size,speed,intel)=br.readLine()!!.split(" ").map { it.toInt() }
        list.add(Shark(size,speed,intel))
    }
    
    for(i in 0 until n){
        for(j in 0 until n){
            if(i==j)    continue
            if(list[i]==list[j]&&i>j){
                adj[i].add(j)
            }
            else if(list[i]>list[j]){
                adj[i].add(j)
            }
        }
    }
    
    fun go(here:Int):Boolean{
        if(visit[here]) return false
        visit[here]=true
        for(there in adj[here]){
            if(B[there]==-1||go(B[there])){
                B[there]=here
                return true
            }
        }
        return false
    }
    
    var count=0
    for(i in 0 until n){
        visit.fill(false)
        if(go(i))   count++
        visit.fill(false)
        if(go(i))   count++
    }
    println(n-count)
}
cs


'BOJ(백준)' 카테고리의 다른 글

[BOJ] 2170번 선 긋기 by Kotlin  (0) 2018.11.13
[BOJ] 1017번 소수 쌍 by Kotlin  (0) 2018.10.07
[BOJ] 1021번 회전하는 큐 - by Kotlin  (0) 2018.10.02
[BOJ] 1068번 트리 byKotlin  (0) 2018.10.02
BOJ 2789번 유학금지 by Kotlin  (0) 2018.07.18

[BOJ] 1021번 회전하는 큐


문제 : 원형 큐에서 현재 위치에서 목적 위치까지 가는데 가장 가까운 방법으로 가는데 드는 비용의 합.



설명 : 큐에 1~N까지 원소를 넣고,  현재 위치는 큐의 첫번째 원소로 생각.

  ( 큐의 첫번째 위치에서 +1 ,  큐의 끝점에서 -1 ) => 반복해서 도착하고자 하는 번호에 먼저 도달하는 것이 비용이 작게 든다. 따라서 먼저 도달한 방법으로   큐의 현재위치(q[0]) 를 이동시킨다.


 만약 현재위치에서 좌측으로 가는 것이 빠르다 => q[0]에 큐의 마지막 원소를 넣고, 마지막 원소를 삭제 : 즉, 좌측으로 이동.

 만약 현재위치에서 우측으로 가는 것이 빠르다 => 큐에 q[0]를 뒤에 추가하고, q[0]를 삭제 : 즉 q[0]를 우측으로 이동

 

 그리고 한칸이동 시 비용을  +1 해주어서 결과값을 얻었다.



(문제 바로가기 : https://boj.kr/1021 )


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*

fun main(args: Array<String>) {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val (n, m) = br.readLine()!!.split(" ").map { it.toInt() }
    val choice = br.readLine()!!.split(" ").map { it.toInt() }.toIntArray()
    val q = LinkedList<Int>()
    for (i in 1..n) q.add(i)
    var res = 0
    var count = 0
    while (count != m) {
        if (q.first == choice[count]) {
            q.poll()
        } 
        else {
            for (i in 1 until q.size) {
                if (q[q.size - i] == choice[count]) {
                    while (q[0!= choice[count]) {
                        q.add(0, q.last)
                        q.removeLast()
                        res++
                    }
                    q.poll()
                    break
                } else if (q[i] == choice[count]) {
                    while (q[0!= choice[count]) {
                        q.add(q.first)
                        q.removeFirst()
                        res++
                    }
                    q.poll()
                    break
                }
            }
        }
        count++
    }
    println(res)
}
cs




'BOJ(백준)' 카테고리의 다른 글

[BOJ] 2170번 선 긋기 by Kotlin  (0) 2018.11.13
[BOJ] 1017번 소수 쌍 by Kotlin  (0) 2018.10.07
[BOJ] 1671번 상어의 저녁식사 by Kotlin  (0) 2018.10.06
[BOJ] 1068번 트리 byKotlin  (0) 2018.10.02
BOJ 2789번 유학금지 by Kotlin  (0) 2018.07.18

BOJ(백준) 1068번 트리



문제 : 입력으로 주어진 트리에서 한 노드를 지웠을 때, 남은 트리에서 리프 노드 개수 구하기.


설명: 

 루트부터 자식들을 BFS로 계속 찾아가는 방법으로 풀었다. 각 노드에 방문시 확인해주면서 leaf 노드의 개수를 추가한다.

 확인하는 것 = 1. 만약 자식의 개수가 1개고, 그 자식이 삭제한 노드이면 . Leaf 노드 이므로 결과값에 +1

                    2. 만약 자식이 없으면 Leaf 노드이므로 결과값에 +1  

 

 

 주어진 입력에서 각 노드의 부모를 배열로 입력받는다.  ex) -1 0 0 1 1   --> 0번 노드는 root이고,  1번,2번 노드의 부모는 0번 노드이고, 3,4번 노드의 부모는 1번 노드이다. 

=> 이 입력을 바꾸어서, parent node 번호에 자식 node 번호를 저장한다.

  adj[노드 번호] 에는 해당 노드의 자식 번호들이 저장되어있다.



(문제 바로가기 : boj.kr/1068)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
 
fun main(args: Array<String>) {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val n = br.readLine()!!.toInt()
    val adj = Array(n) { LinkedList<Int>() }
    var root = 0
    var tmp = 0
    val st = StringTokenizer(br.readLine()!!)
    while (st.hasMoreTokens()) {
        val parent = st.nextToken().toInt()
        if (parent != -1) {
            adj[parent].add(tmp++)
        } else root = tmp++
    }
    val remove = br.readLine()!!.toInt()
 
    val q = LinkedList<Int>()
    var res = 0
    q.add(root)
    while (!q.isEmpty()) {
        val here = q.poll()
        if (here == remove) continue
        if (adj[here].size == 0 || (adj[here].size == 1 && adj[here][0== remove)) {
            res++
            continue
        }
        for (next in adj[here]) {
            if (next != remove) {
                q.add(next)
            }
        }
    }
    println(res)
}
cs


 
 데이터 통신 시스템


  • 메시지 - 메시지(Message)는 통신의 대상이 되는 정보,즉 데이터. 텍스트, 숫자, 그림, 소리, 화상 등.
  • 송신자 - 송신자(Sender)는 데이터 메시지를 보내는 장치. 컴퓨터, 전화기, 비디오 카메라 등.
  • 수신자 - 수신자(Receiver)는 메시지를 수신하는 장치. 컴퓨터, 전화기, TV 등.
  • 전송매체 - 전송매체(Medium)는 메시지가 전송자로부터 수신자에게까지 이동하는 물리적 경로. 꼬임상선(twisted pair wire), 동축 케이블, 광섬유 케이블, 레이저, 무선파 등.
  • 프로토콜 - 프로토콜(Protocol)은 데이터통신을 통제하는 규칙의 집합이다. 프로토콜은 통신하고 있는 장치들 사이의 상호합의를 나타낸다. 프로토콜이 없다면 통신장비가 연결되어 있어도 서로 통신할 수 없게 된다.


데이터 흐름 방향

  • 단방향 (Simplex)
    • 단방향 방식(simplex mode)에서 통신은 한쪽 방향으로만 일어난다.
    • 하나의 링크에 연결되어 있는 두 기지국에서 한쪽은 전송만 할 수 있고, 다른쪽은 수신만 할 수 있다.
    • ex) 자판과 모니터.




  • 반이중(Half-duplex)
    • 반이중 방식(half-duplex mode)에서 각 기지국은 송신과 수신이 가능하지만, 동시에 할 수는 없다.
    • 한 장치가 송신하면 다른장치는 수신만 할 수 있게 된다.
    • 양방향으로 통행이 가능한 외길과 같다. 
    • ex) 워키토키와 민간방송용 라디오(CB radio)




  • 전이중(full-duplex, duplex)
    • 전이중 방식(mode)은 두 대의 단말기가 데이터를 송수신하기 위해 동시에 각각 독립된 회선을 사용하는 통신 방식.
    • 전이중 방식은 양방향으로 통행이 가능한 2차선 도로와 같다.
    • 전이중 방식에서 신호는 링크의 용량을 공유해서 양방향으로 전달된다.
    • ex) 전화망, 고속 데이터 통신




'데이터통신 & 네트워크' 카테고리의 다른 글

이더넷과 토큰링  (0) 2019.01.07
클라이언트와 서버  (0) 2018.12.31

트리의 지름 : 트리에서 임의의 두 점의 거리가 가장 긴 것




구하는 방법


1. 아무 점(A)을 잡고 DFS 혹은 BFS를 돌려서 A에서 가장 멀리 있는(가중치 합이 최대인) 점(U)를 구한다.


2. 구한 점(U)을 시작점으로 DFS 혹은 BFS를 돌려서 U에서 가장 멀리있는(가중치 합이 최대인) V를 구한다.

(여기서 가중치 합이 최대 => 트리의 지름)


3.  U,V가 트리 지름을 만드는 두 점


증명

https://koosaga.com/14

http://blog.myungwoo.kr/112


  • nullable type : null을 가질 수 있는 type (type 뒤에 물음표) 
 
    ex) var str: String? = "AAA"
        str=null     // str은 nullable type으로 null을 가질 수 있다. 
    println(${str.length})    // nullable 타입은 null이 가능하므로 참조하는 것이 위험하다.=> str이 null일 때 Error가 난다. 

  • nullable type의 참조의 방법 
 ex)
  println(${str?.length}) // save call을 하는 방법 ,   str이 null이면 null 출력.
   println(${str!!.length})  //   느낌표 2개를 붙이면 str이 null 이라도 참조/호출 . str이 null인 경우 null pointer exception 발생
  println(${str?.length ?: "null이면 여기 출력됨"})     // elvis operator와 함께 사용할 수 있다.

      

  • non-null type : null을 가질 수 없는 type
ex) var str : String = "AAA"
    str=null   //   -> str은 non-null type이라 null을 가질 수 없다. 따라서 Error


'Kotlin' 카테고리의 다른 글

[Kotlin] Any 클래스, 타입 체크  (3) 2018.07.18
[Kotlin] 기본 자료형, 변수와 상수  (0) 2018.07.18

메모리 관리
  • 주기억장치는 운영체제(상주 모니터, 커널)를 위한 곳과, 현재 수행중인 프로그램을 위한 공간으로 구분된다.
  • 멀티프로그래밍 시스템에서는 주기억장치의 사용자 영역이 다수의 프로세스들을 수용하기 위해 더 여러개로 나뉘게 된다. 이와 같은 분할 작업은 운영 체제에 의해서 동적으로 이루어지며, 이를 메모리 관리라고 한다.


메모리 관리 관련 용어
  • 프레임 (Frame) : 주기억장치의 고정 길이 블록
  • 페이지 (Page) : 보조기억장치에 있는 데이터의 고정 길이 블록. 한 페이지의 데이터는 한 프레임의 주기억장치에 임시로 복사될 수 있다.
  • 세그먼트 (Segment) : 보조기억장치에 있는 데이터의 가변 길이 블록. 전체 세그먼트는 주기억장치의 사용 가능한 공간에 임시로 복사될 수 있거나 (세그먼테이션), 주기억장치로 일일이 복사될 수 있는 페이지들로 분할 될 수 있다. (세그먼테이션과 페이징의 결합)




메모리 관리기법 종류
  • 반입 정책(전략)
        - 언제 메모리로 적재할 것인지 결정하는 전략
        - 메인메모리에 적재할 다음 프로세스의 반입시기를 결정
        - 기법 : 요구반입기법, 예상반입기법

  • 배치 정책(전략)
        - 어디로 위치시킬 것인지 결정하는 전략
        - 디스크에서 반입한 프로세스를 메인 메모리의 어느 위치에 저장할 것인지를 결정하는 방법
        - 기법 : 최초적합(first-fit), 최적적합(best-fit), 최악적합(worst-fit), 순환적합(next-fit)
        - 최초적합: 메모리의 처음부터 검사해서 크기가 충분한 첫 번째 사용 가능한 메모리 블록을 선택한다.
        - 최적적합: 요청한 크기와 가장 근접한 크기의 메모리를 선택한다. 가용 공간들에 대한 목록이 그 공간들의 크기 순서대로 정렬되어 있지 않다면 최적인 곳을 찾기 위해 전체를 검색해야 한다.
        - 최악적합: 사용 가능한 공간들 중에서 가장 큰 것을 선택한다. 할당해주고 남는 공간을 크게하여 다른 프로세스들이 그 공간을 사용할 수 있도록 하는 전략. 최적 적합과 마찬가지로, 가용 공간들에 대한 목록이 그 공간들의 크기 순서대로 정렬되어 있지 않다면 최적인 곳을 찾기 위해 전체를 검색해야 한다.
        - 순환적합: 가장 최근에 배치되었던 메모리의 위치에서부터 검사를 시작해 크기가 충분한 다음 위치의 사용 가능한 메모리 블록을 선택한다.

  • ​교체 정책
        - 메모리의 어느 영역을 교체하여 사용할 것인지 결정하는 전략
        - 재배치 기법으로 메인 메모리에 있는 어떤 프로세스를 제거할 것인가를 결정
        - 기법: 프로세스 Swap In/Out



연속 메모리 할당 방식

  • 연속 메모리 할당
        - 메모리의 영역을 사용자를 위한 공간과 운영체제 상주를 위한 공간으로 구분하는 기법
        - 메모리를 운영체제 루틴이 들어있는 부분(모니터)과 사용자 프로그램이 들어있는 부분, 사용되지 않는 부분으로 구분
        - 사용자가 모든 메인 메모리에 대한 제어권을 가짐
        - 사용자 프로그램이 주소를 잘못 지정하면 운영체제 파괴
        - 운영체제 파괴 방지를 위한 프로세서 내 경계 레지스터를 둠
        - 사용자 프로그램이 메모리 참조할 때마다 경계 레지스터 검사 이후 실행

  • 고정 분할
        - 메모리를 여러 개의 고정된 크기로 분할. (partition)
        - 고정된 크기의 분할 영역에 프로세스가 각각 할당됨.
        - 물리주소는 분할 기준 레지스터(PBR) 값에 논리 주소를 더하여 생성됨
        - 강점 : 구현이 간단하다 = 운영체제에 오버헤드가 거의 없다.
        - 약점 : 내부단편화로 인한 비효율적인 사용. 최대 활성 프로세스의 수가 고정됨
           


  • 가변 분할(동적 분할)
        - 메인메모리의 사용자 공간 전체를 하나의 분할 영역으로 설정하고, 이후 프로세스의 움직임에 따라 분할 형태를 동적으로 변화시키는 기법
        - 강점 : 내부단편화가 없고, 주기억장치를 보다 효율적으로 사용할 수 있다.
        - 약점 : 외부 단편화를 해결하기 위한 메모리 집약(Compaction)이 요구된다. 따라서 처리기 효율이 나빠진다. (오버헤드 발생)




 분산 메모리 할당 방식
  • 페이징 기법
        - 동일 크기의 프레임 분할.
        - 페이지라고 불리는 프로세스 영역들이 프레임(페이지 프레임)이라고 불리는 고정크기 블록의 메모리 영역에 할당.
            => 즉, 주기억장치를 고정 사이즈 파티션으로 나누고 각 프로세스 또한 같은 크기의 고정 조각으로 나눈다!
        - 내부 단편화 발생, 외부 단편화 없음
        - 각 페이지를 연속된 공간에 넣을 필요가 없지만, 프로세스의 각 페이지들에 해당하는 프레임의 위치를 저장하기 위해 운영체제는 각 프로세스마다 하나의 페이지 테이블(page table)을 유지한다.
        - 페이지 테이블 : 논리메모리 페이지 번호와 물리메모리 프레임 번호를 매핑.


  • 세그먼트 기법(세그먼테이션)
        - 분할되는 프로그램 블록들을 세그먼트라 하며, 각 세그먼트들의 크기는 서로 다르게 되어 있다.
        - 크기가 다르기 때문에 주기억장치 영역을 페이징 시스템에서와 같이 미리 분할해 둘 수 없으며, 주기억장치에 적재될 때 빈 공간을 찾아 할당하는 방법.
        - 단점 : 프로그래머가 세그먼트의 최대 크기를 알고 있어야한다.
                    논리주소와 물리주소 간에 복잡한 관계가 존재한다.
                    외부 단편화 문제 발생.
        - 동적 할당과 차이점은 세그먼테이션의 경우 프로그램이 하나 이상의 파티션을 차지할 수 있고, 이 파티션들이 연속적일 필요는 없다는 점.



CPU Scheduling
  • Process 작업수행을 위해 언제, 어느 Process에 CPU를 할당할 것인지를 결정하는 작업.




CPU Scheduling 요건 (Scheduling Criteria)
  • 처리 능력(Throughput) 최대화 : 주어진 시간에 최대한 많은 작업을 처리
  • 반환시간(Turnaround time) 최소화 : 프로세스가 시스템으로 진입한 후부터 종료할 때까지 걸린 시간의 최소화
  • 대기시간(Waiting time) 최소화 : Ready queue에서 기다리는 시간 최소화
  • 응답시간(Response time) 최소화 : 대화형 프로세스가 시스템에 요구를 한 후 이에 대한 시스템으로부터의 첫 번째 응답이 올 때까지의 시간의 최소화
  • CPU 이용률(Utilization) 극대화





Process 상태전이도와 Scheduler의 종류 및 역할

  • 프로세스 상태 전이도
    
    <출처 : ilifo >

  • 스케줄러의 종류 및 역할
        - 장기(Job) Scheduler : 프로세스 선택, 주기억장치 할당 (보류-준비)
        - 중기(Process) Scheduler : 프로세스 수에 따라 디스크에 보냄(대기-보류) , 프로세스들이 CPU를 서로 차지하려고 할 때 프로세스를 기억장소(main memory)에서 잠시 빼내고 다시 메인 메모리에 들여보내 실행시킬 수 있는 교체(Swapping) 기법을 사용한다.
        - 단기 Scheduler : 실행 준비된 프로세스에 CPU 할당 (준비-실행)





CPU Scheduling 기법
  • 선점(Preemptive) 스케줄링 
        - 개념 : 어떤 프로세스가 CPU를 할당 받아 실행 중에 있어도 다른 프로세스가 실행 중인 프로세스를 중지시키고 CPU를 강제로 점유할 수 있다.  (우선순위에 따라 CPU를 빼앗을 수 있다.)
                    높은 우선순위를 가진 프로세스들이 빠른 처리를 요구하는 시스템에서 유리
        - 장점 : 비교적 빠른 응답
                   대화식 시분할 시스템에 적합
        - 단점 : 높은 우선순위 프로세스들이 들어오는 경우 오버헤드 초래

  • 비선점(Non-Preemptive) 스케줄링
        - 어떤 프로세스가 CPU를 할당 받으면 그 프로세스가 종료되거나 입출력 요구가 발생하여 자발적으로 중지될 때까지 계속 실행되도록 보장한다. (CPU를 빼앗지 못한다.)
        - 일괄처리 시스템에 적합.
        - 장점 : 응답시간 예상이 용이
                   모든 프로세스에 대한 요구를 공정하게 처리
                   스케줄러 호출 빈도가 낮고 Context switching에 의한오버헤드가 적다.
        - 단점 : CPU 사용 시간이 긴 하나의 프로세스가 CPU 사용 시간이 짧은 여러 프로세스를 오랫동안 대기시킬 수 있으므로, 처리율이 떨어질 수 있다.







비선점(Non-Preemptive) 스케줄링 알고리즘
  • FCFS(First-Come-First-Served)=FIFO(First-In-First-Out)
        - 프로세스가 대기큐(준비큐)에 도착한 순서대로 CPU 할당하는 스케줄링 알고리즘.
        - Convoy Effect 발생 가능 (Burst time이 긴 프로세스가 CPU 독점)
        - 단독적 사용이 거의 없으며, 다른 스케줄링 알고리즘에 보조적으로 사용 (우선순위 스케줄링, RR 스케줄링 등)

  • SJF (Shortest Job First)
        - 준비 큐 내의 프로세스 중 CPU 점유시간이 가장 짧은 프로세스에 CPU를 먼저 할당하는 스케줄링 알고리즘.
        - 주어진 프로세스 집합에 대해서 평균 대기시간이 최소가 되는 최적 알고리즘
        - CPU 요구시간이 긴 작업과 짧은 작업간의 불평등이 심하여, CPU 요구시간이 긴 프로세스는 Starvation(기아상태) 발생 가능.

  • HRN (Highest Response ratio Next)
        - 프로세스 처리의 우선순위를 CPU 처리 기간과 해당 프로세스의 대기 시간을 동시에 고려해 선정하는 스케줄링 알고리즘
        - Response ratio = (대기시간 + 서비스 시간) / 서비스 시간
        - 대기중인 프로세스 중 현재 Response Ratio가 가장 높은 것을 선택
        - SJF의 약점을 보완한 기법으로 긴 작업과 짧은 작업간의 불평등을 완화

  • 우선순위 스케줄링
        - 각 프로세스에 우선순위가 주어지고 우선순위에 따라 CPU 할당하는 스케줄링 알고리즘
        - 동일한 우선순위간은 FCFS 처리
        - 우선순위 결정 : 관리자에 의한 결정, 자원요구량에 의한 결정, CPU처리 시간에 의한 결정, 시스템에서 보낸 시간에 의한 결정 등 사용
        - 우선순위가 높은 작업이 계속적으로 들어오게 될 경우 우선순위가 낮은 프로세스는 starvation 발생 -> Aging 기법으로 해결







선점(Preemptive) 스케줄링 알고리즘
  • RR(Round Robin)
        - 시분할 시스템을 위해 설계된 선점형 스케줄링의 하나로서, 프로세스들 사이에 우선순위를 두지 않고, 순서대로 시간단위(Time Quantum)로 CPU를 할당하는 스케줄링 알고리즘
        - 시간 단위동안 수행한 프로세스는 준비 큐의 끝으로 밀려나게 됨
        - 문맥 전환의 오버헤드가 큰 반면, 응답시간이 짧아지는 장점이 있어 실시간 시스템에 유리하다.
        - 시간 단위가 크면 FCFS와 같게 된다.

  • SRT(Shortest Remaining Time)
        - 가장 짧은 시간이 소요된다고 판단되는 프로세스를 먼저 실행.
        - 남은 처리 시간이 더 짧다고 판단되는 프로세스가 준비 큐에 생기면 언제라도 프로세스가 선점됨
        - 긴 작업은 SJF 보다 대기 시간이 길다.

  • 다단계 큐(Multilevel Queue)
        - 커널 내의 준비 큐를 여러 개의 큐로 분리하여 큐 사이에도 우선순위를 부여하는 스케줄링 알고리즘.

  • 다단계 피드백 큐(Multilevel Feedback Queue)
        - 다단계 큐 스케줄링에서 한 단계 발전된 방식으로, 다단계 큐 스케줄링에서는 프로세스가 하나의 큐에 영구적으로 할당되지만, 다단계 피드백 큐 스케줄링에서는 프로세스들이 큐를 갈아탈 수 있다.
        - 작업들이 서로 다른 유형의 작업들로 분류될 경우 사용.
        - 새로운 프로세스는 높은 우선순위, 프로세스의 실행시간이 길어질수록 점점 낮은 우선순위 큐로 이동 (맨 마지막 단계에서는 RR 처리)

        - 하위단계일수록 할당시간은 증가 (공평성 부여)
        <출처 : ilifo >

















    

'운영체제' 카테고리의 다른 글

메모리 관리  (0) 2018.09.01
커널(Kernel), 마이크로 커널&모놀리식 커널  (0) 2018.08.28
캐시 메모리(Cache Memory)  (0) 2018.08.28
교착상태(Deadlock)  (0) 2018.08.28
세마포어와 뮤텍스 (Semaphores&Mutex)  (0) 2018.08.26

커널 (Kernel)
  • 커널은 컴퓨터의 운영체제의 핵심.
  • main memory에 상주하며, 시스템에 존재하는 자원을 효율적으로 관리하는 자원 관리자.
                        <General UNIX Architecture, Traditional UNIX kernel>



커널의 역할
  • 보안 - 컴퓨터 하드웨어와 프로세스의 보안을 책임진다.
  • 프로세서 관리 - 처리 속도를 향상시키기 위해 여러 프로세서를 병렬로 연결하여 사용한다. 시스템에서 동작하는 프로세스도 커널에서 관리해야할 자원이고, 운영체제의 처리 요구에 맞춰 동작할 수 있도록 각 프로세스에 필요한 프로세서를 효율적으로 할당하고 수행하도록 관리한다.
  • 프로세스 관리 - 여러 프로세스가 동작할 수 있도록 각 프로세스를 생성하고 제거하며, 외부환경과 프로세스를 연결하고 관리한다. (스케줄링)
  • 메모리 관리 - 각각의 프로세스가 독립적인 공간에서 수행할 수 있도록 가상 주소 공간을 제공한다.
    이외에도 파일 시스템 관리, 디바이스 제어, 네트워크 관리가 있다.



모놀리식 커널(Monolithic Kernel,단일형 커널)과 마이크로커널(Micro Kernel)

  • 모놀리식 커널
        - 입출력 기능, 네트워크 기능, 장치 지원 등 운영체제의 일반적인 기능을 커널과 동일한 메모리 공간에 적재, 실행하는 기법.
       - 속도가 빠르고 디자인도 편리하지만, 잠재적 안정성 문제와 커널의 크기도 무지막지하게 커진다. 
        - Monolitic Kernel 방식을 따르는 운영체제 : 리눅스, 보통의 UNIX, 맥OS, MS-DOS





  • 마이크로 커널
        - 낮은 수준의 주소 공간 관리, 스레드 관리, 프로세스 간 통신(IPC)를 포함하고, 시스템 콜 같은 서비스, 디바이스 관리 등을 제외하여 안정성을 높이고, 커널 크기도 줄인 방식.
        - 안정성이 높고 보안도 높아지지만, 전반적인 퍼포먼스는 저하된다.
        - 이 방식을 따르는 운영체제 : AmigaOS, Minix, Mach, GNU hurd









     
     


'운영체제' 카테고리의 다른 글

메모리 관리  (0) 2018.09.01
CPU Scheduling (CPU 스케줄링)  (0) 2018.08.30
캐시 메모리(Cache Memory)  (0) 2018.08.28
교착상태(Deadlock)  (0) 2018.08.28
세마포어와 뮤텍스 (Semaphores&Mutex)  (0) 2018.08.26


캐시 메모리 (Cache Memory)
        
  <출처 : wikipedia >
  • CPU 칩 안에 포함되는 빠르고 작은 메모리.
  • 속도가 빠른 장치와 느린 장치간의 속도차에 따른 병목 현상을 줄이기 위한 범용 메모리
  • 프로그램에서 직접적으로 읽거나 쓸 수 없고, 하드웨어 메모리 관리 시스템이 내부적으로 제어한다.
  • 데이터 지역성을 활용해서 메인 메모리에 있는 데이터를 캐시 메모리에 불러와 두고, CPU가 필요한 데이터를 캐시에서 먼저 찾도록 하면 시스템 성능을 향상시킬 수 있다.




캐시 메모리의 설계 목표
  • Cache 적중율(Hit Rate)의 극대화로 Cache Access 시간 최소화
  • Cache 실패율(Miss Rate)에 따른 지연시간(Miss Penalty)의 최소화
  • 공유 메모리와 Cache 간의 일관성 유지






캐시 메모리의 특징
  • Locality(지역성) : 블록 단위의 메모리 참조 (시간, 공간)
  • Mapping(매핑) : 주기억 장치와 캐시 메모리 간의 메모리매핑 적용 (직접, 연관)
  • Coherence(일관성) : 병렬 처리시 Local Cache와 공유 메모리간 데이터 일관성 유지 (공유 Cache)





캐시 메모리 적중률 극대화 원리 : Locality
  • 시간적 지역성 : 최근 사용된 데이터의 재 이용율이 높음. (ex. Loop, Stack, Sub Program)
  • 공간적 지역성 : 최근 사용된 데이터의 인접 데이터의 사용율이 높음 (ex. Array, 순차코드)
  • 순차적 지역성 : 데이터가 기억장치에 저장된 순서대로 순차적으로 인출되고 실행될 가능성이 높음




캐시 미스가 나는 경우
  • Compulsory miss : 해당 메모리 주소를 처음 불렀기 때문에 나는 캐시 미스. 
  • Conflict miss : 캐시 메모리에 A데이터와 B데이터를 저장해야되는데, A와 B가 같은 캐시 메모리 주소에 할당되어서 나는 캐시 미스.
  • Capacity miss : 캐시 메모리에 공간이 부족해서 나는 캐시 미스.





 캐시 메모리와 주기억장치 Mapping
  • 캐시 메모리 Mapping 목적
        - Cache의 용량이 주기억장치의 용량보다 적기 때문에 주기억장치의 일부분만 캐시로 적재될 수 있음.
        - 제한된 캐시 용량으로 최고의 적중률을 얻을 수 있는 방법 필요.

  • 캐시 메모리 Mapping 기법의 종류
            - Direct Mapping 
             개념 : 메인 메모리를 일정한 크기의 블록으로 나누고 각각의 블록을 캐시 위 정해진 위치에 매핑하는 방식
              장점 : 가장 쉽고 간단
              단점 : 비어 있는 라인이 있더라도 동일 라인의 메모리 주소에 대하여 하나의 데이터밖에 저장 할 수 없음. 캐시의 성능을 저하시킴

            - Full Associative Mapping
             개념 : 직접매핑 방식의 단점을 개선하기 위해 태그 필드를 확장하여 캐시의 어떤 라인과도 무관하게 매핑 시킬수 있는 매핑 방법
             장점 : 캐시를 효율적으로 사용하게 하여 캐시의 히트율 증가
             단점 : 구성과 과정이 매우 복잡

            - Set Associative Mapping
             개념 : 위의 두 매핑방식의 장점을 취하고 단점을 최소화한 절충안. 캐쉬를 N개의 세트들로 나누고 각 세트들은 L개의 라인들로 이루어지게 구성. 전체 메인 메모리는 각 세트의 크기인 32Kbyte 단위로 나뉘어 태그 값이 매겨지고(Direct Mapping) 각각 4Kbyte 단위의 라인 사이즈로 다시 나뉘어져 각각의 세트에 매핑(Associative Mapping)







캐시 메모리 교체 알고리즘

  • FIFO (First-In-First-Out) : 캐시 내에 가장 오래 머물러 있었던 블록 교체.
  • LRU (Least Recently Used) : 사용되지 않고 가장 오래 캐시에 머물러 있던 블록 교체.
  • LFU (Least Frequently Used) : 캐시 내에 있는 블록 중 가장 사용빈도가 낮은 블록을 교체.
  • Optimal : 향후 가장 참조되지 않을 블록 교체.




+ Recent posts