Vamos ser Programador com Devfon

System Structure & Program Execution

컴퓨터 시스템 구조

• CPU는 매 클록 주기 마다 Memory에서 명령어를 읽어와 명령 수행
• Memory는 CPU의 작업 공간
• 사용자 프로그램이 I/O 요청할 때는 운영체제에게 CPU를 넘기고, 요청한 작업이 끝나 결과를 받을 때 까지 대기
  • 그 동안 CPU는 다른 프로그램을 수행
  • CPU는 매 프로그램의 종료 이후, 들어온 Interrupt가 있는지 확인

Mode bit

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

• Mode bit을 통해 하드웨어적으로 2가지 모드의 Operation 지원

  • 사용자 모드(1): 사용자 프로그램 수행
    • 제한된 접근, 프로그램의 수행만 가능
  • 커널 모드(0): OS 코드 수행
    • 모든 접근, 프로그램의 수행이 가능
• 보안을 해칠 수 있는 중요한 명령어는 커널 모드에서만 수행 가능한 특권 명령으로 규정
• Interrupt나 Exception 발생 시, 하드웨어가 mode bit을 0으로 세팅
• 사용자 프로그램에게 CPU를 넘기기 전에 mode bit을 1로 세팅

Timer

• CPU를 특정 프로그램이 독점하는 것으로부터 보호
• 정해진 시간이 흐른 뒤, 운영체제에게 제어권이 넘어가도록 Interrupt를 발생시킴
• Timer는 매 Clock tick 마다 1씩 감소
• Timer 값이 0이 되면 Timer Interrupt 발생
• Timer는 Time Sharing을 구현하기 위해 널리 이용됨
• 또한, 현재 시간을 계산하기 위해서도 사용

Device Controller

• 각 I/O 장치 유형을 관리하는 일종의 작은 CPU
• 제어 정보를 위해 Control, Status register를 가짐
• I/O 장치의 결과를 저장하기 위한 Local buffer를 가짐
• I/O는 실제 Device와 Local buffer 사이에서 일어남
• Device Controller는 I/O가 끝났을 경우, Interrupt로 CPU에 그 사실을 알림
• Device Driver(장치 구동기): OS 코드 중 각 장치별 처리 루틴 -> Software

I/O의 수행

• 모든 입출력 명령은 특권 명령 through.OS
• 사용자 프로그램은 어떻게 I/O를 하는가?
  • System Call
    • 사용자 프로그램이 운영체제의 서비스를 받기 위해 커널 함수를 호출하는 것
  • Trap을 사용하여 인터럽트 벡터의 위치로 이동
  • 제어권이 인터럽트 벡터가 가리키는 인터럽트 서비스 루틴으로 이동
  • 올바른 I/O 요청인지 확인 후, I/O 수행
  • I/O 완료 시, 제어권을 System Call 다음 명령으로 옮김
• 즉, I/O의 수행을 위해서는 2가지 인터럽트가 걸리는 것
  • I/O 요청 시의 Software Interrupt + I/O 완료 시의 Hardware Interrupt

Interrupt

• 인터럽트 당한 시점의 Register와 PC를 저장한 후, CPU의 제어를 인터럽트 처리 루틴에 넘김
• Interrupt: 하드웨어가 발생시킨 인터럽트
• Trap: 소프트웨어가 발생시킨 인터럽트
  • Exception: 프로그램이 오류를 범한 경우
    • ex) 운영체제의 메모리 접근, divide by zero
  • System call: 프로그램이 커널 함수를 호출하는 경우
• 인터럽트 관련 용어
  • 인터럽트 벡터: 해당 인터럽트의 처리 루틴 주소를 가지고 있음
  • 인터럽트 처리 루틴(인터럽트 핸들러): 해당 인터럽트를 처리하는 커널 함수

동기식 입출력과 비동기식 입출력

• 동기식 입출력(Synchrounous I/O)
  • I/O 요청 후, 입출력 작업이 완료된 후에야 제어가 사용자 프로그램에 넘어감
  • 구현 방법 1
    • I/O가 끝날 때 까지 CPU를 낭비
    • 매 시점 하나의 I/O만 일어날 수 있음
  • 구현 방법 2
    • I/O가 완료될 때 까지 해당 프로그램에게서 CPU를 빼앗음
    • I/O 처리를 기다리는 줄에 그 프로그램을 줄 세움
    • 다른 프로그램에게 CPU를 줌
    • I/O 요청이 끝나면 바로 요청했던 프로그램에게 CPU를 넘겨줌
• 비동기식 입출력(Asynchrounous I/O)
  • I/O가 시작된 후, 입출력 작업이 끝나기를 기다리지 않고 제어가 사용자 프로그램에 즉시 넘어감
• 두 경우 모두 I/O의 완료는 Interrupt로 알려줌
• I/O 결과가 다음 명령어 실행에 영향을 미치는 경우, 동기식 입출력을
• 그렇지 않을 경우, 비동기식 입출력을 사용할 수 있음

DMA(Direct Memory Access)

• 빠른 입출력 장치를 메모리에 가까운 속도로 처리하기 위해 사용
• CPU의 중재 없이 Device controller가 device의 Buffer storage 내용을 메모리에 Block 단위로 직접 전송
• Byte 단위가 아니라 Block 단위로 Interrupt 발생시킴

서로 다른 입출력 명령어

1. Using I/O instruction: 메모리 접근하는 명령어 따로, I/O 장치 접근하는 명령어를 따로 두는 명령어 방식
2. Memory Mapped I/O: I/O 장치들에 메모리 주소를 메겨, 메모리의 연장 선상으로 사용하는 방식

프로그램의 실행 (메모리 Load)

• 프로그램은 '실행 파일' 형태로 File System에 저장
• 각 프로그램은 프로세스로 변환되면서 고유의 Address space 형성
  • code, data, stack 등으로 구성
  • Kernel 역시 주소 공간을 형성하여 메모리에 올라감
• 각 프로세스는 Address translation을 통해 Physical memory에 탑재
• 프로그램의 실행을 위해 Memory에 올라가있을 필요가 없는 메모리들은 Swap area(HDD)에 내려 놓음
  • 일종의 Memory 연장 공간

커널 주소 공간의 내용

• 어떤 사용자 프로그램이 커널 코드를 실행 중인지에 대해 알기 위해 프로세스 마다 커널 스택을 따로 둠

사용자 프로그램이 사용하는 함수

• 사용자 정의 함수
  • 자신의 프로그램에서 정의한 함수
• 라이브러리 함수
  • 자신의 프로그램에서 정의하지 않고 가져다 쓰는 함수
  • 자신의 프로그램의 실행 파일에 포함되어 있음
• 커널 함수
  • 운영체제 프로그램의 함수
  • 커널 함수의 호출 = 시스템 콜

Introduction to Operating Systems

운영체제란?

• 컴퓨터 하드웨어 바로 위에 설치되어 사용자 및 다른 모든 소프트웨어와 하드웨어를 연결하는 소프트웨어 계층
• 협의의 운영체제(커널): OS의 핵심 부분으로 메모리에 상주하는 부분
• 광의의 운영체제: 커널 뿐 아니라 메모리에 상주하지 않는 각종 주변 시스템 유틸리티를 포함하는 개념

운영체제의 목적

• 컴퓨터 시스템을 편리하게 사용할 수 있는 환경을 제공
  • 운영체제는 동시 사용자 / 프로그램들이 각각 독자적 컴퓨터에서 수행되는 것처럼 보이게 함
  • 하드웨어를 직접 다루는 복잡한 부분을 운영체제가 대행
• 컴퓨터 시스템의 자원을 효율적으로 관리
  • 프로세서, 기억장치, I/O 장치 등의 효율적 관리
    • 사용자 간 형평성 있는 자원 분배
    • 주어진 자원으로 최대한의 성능을 내도록 함
      • 실행 중 프로그램들에게 짧은 시간 씩 CPU를 번갈아 할당
      • 실행 중 프로그램들에게 메모리 공간을 적절히 분배
  • 사용자 및 운영체제 자신의 보호
  • 프로세스, 파일, 메시지 등을 관리(소프트웨어 자원)

운영체제의 분류

1. 동시 작업 가능 여부
   • 단일 작업(single tasking): 한 번에 하나의 작업만 처리
     • ex) MS-DOS 프롬프트 상에서는 한 명령의 수행을 끝내기 전에 다른 명령을 수행시킬 수 없음
   • 다중 작업(multi tasking): 동시에 두 개 이상의 작업 처리
     • ex) UNIX, MS Windows 등에서는 한 명령의 수행이 끝나기 전에 다른 명령이나 프로그램을 수행할 수 있음
2. 사용자의 수
   • 단일 사용자(single user)
     • ex) MS-DOS, MS Windows
   • 다중 사용자(multi user)
     • ex) UNIX, NT Server
3. 처리 방식

   • 일괄 처리(Batch processing)

     • 작업 요청의 일정량을 모아 한꺼번에 처리
     • 작업이 완전히 종료될 때까지 기다려야 함
       • ex) 초기 Punch card 시스템

   • 시분할(Time sharing)

     • 여러 작업을 수행할 때 컴퓨터 처리 능력을 일정한 시간 단위로 분할하여 사용
     • 일괄 처리 시스템에 비해 짧은 응답 시간을 가짐
     • 사용자 입장에서는 interactive한 방식

   • 실시간(Realtime OS)

     • 정해진 시간 안에 어떠한 일이 반드시 종료됨이 보장되어야 하는(dead-line) 실시간 시스템을 위한 OS
     • 실시간 시스템의 개념 확장
       • Hard Realtime System
         • ex) 미사일 제어, 원자로/공장 제어
       • Soft Realtime System
         • ex) 영화 스트리밍
     • 실시간성을 필요로 하는 어플리케이션이 늘어남에 따라 범용 운영체제 역시 어떻게 '실시간성'을 지켜줄 것인가에 대한 연구를 진행(ex. 블랙박스, 네비게이션)

혼동하기 쉬운 용어

• Multitasking
• Multiprogramming
• Time sharing
• Multiprocess
• 위 용어들은 컴퓨터에서 여러 작업을 동시에 수행하는 것을 뜻함
• Multiprogramming은 여러 프로그램이 메모리에 올라가 있음을 강조
• Time sharing은 CPU의 시간을 분할하여 나누어 쓴다는 의미를 강조

운영체제의 구조

두다지 서버 개발자 양성 프로그램 Week 4

4번 째 멘토링

한 주 간 컴퓨터구조론, Linux 그리고 Vim에 대한 학습을 마친 후, 학습한 지식에 대한 리뷰 시간을 가져보았다. 일주일 간 책을 기반으로 전산학의 기본 지식들을 학습하면서 내가 얻은(혹은 공부한) 지식에 대한 확신을 잘 얻지 못하였는데, 이번 시간 내가 학습한 것을 남에게 직접 설명하는 시간을 가져보며 학습한 지식을 내것으로 소화할 수 있었던 시간이었다. 단순히 책을 읽고 학습이 완료되었다고 생각하는 것이 아니라, 학습한 지식을 소화하여 내 것으로 만들 수 있는 시간을 충분히 가져갈 수 있어야 한다는 생각을 다시금 느낄 수 있었던 시간이었다.

학습한 것에 대한 리뷰

• Vim에서 중요한 옵션
  • textwidth: 80-Columns Rule을 지키기 위한 옵션
  • expandtab: Tab이 아닌 4-spaces를 사용하기 위한 옵션
  • Syntax Highlight
• 리눅스에서는 Quotation으로 원치 않는 확장 막아주는 것이 중요
  • 쉘 스크립트 작성에 중요한 요소이기 때문
  • Should know difference between Double Quotation and Single Quotation!
    • Double Quotation: 변수, `(backtick), escape 문자 등 특정 대상에 대한 확장 허용
    • Single Quotation: 어떠한 확장도 허용하지 않음

>> $ echo "$(echo "upg")"
upg
>> $ echo '$(echo "upg")'
$(echo "upg")

• su는 다른 유저로 전환을 하기 위한 명령어
  • default 값이 Super user인 것이며, 인자를 넣어줌으로써 다른 User로의 전환이 가능

feedback

• 전산학에 나오는 용어를 적재적소에 정확하게 사용하여 설명해야 함
  • 대명사 사용은 지양하는 것이 좋음(ex: 그거, 저거...)
  • 어떠한한 언어다.. 어떠한 프레임워크다.. 어떠한한 하드웨어 구성 요소이다.. 와 같이 정확한 끝말을 사용해야 함
• 전산학의 경우, 자연과학과 달리 필요에 의하여 만들어진 것이기 때문에 왜 그러한 Concepts가 생겨난 것인지에 대한 이유를 잘 이해하고, 설명할 수 있어야 함
  • 어떤 배경에서 이러한 개념이 발생한 것인가?
  • 이전 기술의 한계, 소비자의 요구 등..
• 이전 기술의 경우: 왜 그 당시 유행할 수 있었는지, 어떻게 다른 기술로 대체되어 왔는지에 대한 이해
• 현재 기술의 경우: 현재 어느 분야에서 많이 사용되고 있는지 이해
  
  

Computer Architecture

Cache

• Cache는 전산학에서는 저장장치이며, 현실 세계에서는 일종의 컨닝 페이퍼
  • Cache가 기능할 수 있는 이유는 Locality의 원리 때문
  • 결국, locality가 없는 곳에서는 cache를 사용하지 않아야 함
  • hit ratio가 0.9 이상이 되어야 사용하는 데 의미가 있음
    • hit ratio가 높다는 것은 locality가 크다는 의미!
• Cache에서 가장 큰 문제는 데이터 불일치
  • 따라서 쓰기 정책을 잘 아는 것이 중요함
  • Write-through, Write-back...
• 사상 정책: Cache를 어떤 구조로 가져갈 것인가?
  • 직접 사상은 O(1)로 해당 value을 찾아올 수 있지만, 해시 펑션에 의해 캐시 공간을 낭비할 가능성이 있음
  • 직접-연관 사상, 세트-연관 사상이 나오게 된 배경!
• Web Cache: 이미지와 같은 경우 사이트에서 매번 가져오는 것이 비효율
  • 크기도 크고, 변할 가능성이 크지 않기 때문에
  • 따라서, 이미지에 대한 해당 url 요청을 Caching하여 정보 제공
    • 이 때는 Disk가 Cache의 역할 수행
    • Web으로부터 가져오는 것 보다는 Disk가 빠르기 때문에!
  • 그러나 해당 url 내 정보가 바뀐 경우는?
    • timeout 정책 적용을 통해 해결 가능. 일정 시간 지나면 cache된 url 정보 삭제
    • 혹은 브라우저의 캐시 기능을 해제하여 해결 가능 -> 개발할 때는 브라우저의 캐시 옵션 제거하고 하는 것이 좋음
• CDN(Content Delivery Network): 콘텐츠를 효율적으로 전달하기 위해 여러 노드를 가진 네트워크에 데이터를 저장하여 제공하는 시스템
  • ex) 리니지 M이 업데이트 됨

  • NC Soft에 있는 전사 네트워크에는 기존 리니지 프로그램을 넣어 놓고, CDN에는 패치 프로그램 넣음
    

  • 새로운 콘텐츠(패치 프로그램)는 무조건 받을 수 밖에 없기 때문에 hit ratio(kinda)는 100%에 달하게 됨
    

Pipelining

• 슈퍼파이프라이닝이란 가장 오래 걸리는 작업을 더 잘게 나누어서 수행하도록 하는 것
• 각 CPU 코어가 자신의 일을 수행하지 못하고 idle 상태에 들어가는 것이 모두 Hazard
• 파이프라인을 증축시키고자 하는 것이 슈퍼스칼라
• 과거의 분기 예측 문제: 분기 되는 것이 common인가? 분기 되지 않는 것이 common인가?
  • ex) Error case에서의 분기문의 경우, 대부분의 경우 프로그램이 정상 작동할 것으로 가정하여 분기 되지 않는 것이 Common case로 설정
  • 현대에서는 이러한 최적화 문제가 잘 해결되어 있음
• 4-line Pipeline이 가격 대비 성능이 좋기 때문에 사용되었던 것이지, 항상 4-line을 사용할 필요는 없음

System bus

• 시스템 버스에서 가장 중요한 개념은 버스 중재
  • 복수의 버스 마스터가 동시에 Signal을 내면 다 같이 무너지기 때문!
• Asynchronous I/O
  • Push:: 특정 event 발생하면 Push 알림
    • ex) 네이버 카페 키워드 알림
    • ex) 특정 프로세스가 DMA 기다리며 sleep 하는 경우
  • SOLID에서의 DIP(Dependency Inversion Principle)
    • ex) Hollywood 오디션의 예

      1000명의 오디션 지원자가 오디션
      지원자들의 합격 문의 전화로 인해 업무 마비
      전화 수신을 거부하고, 발표일에 일괄 발표하겠음!
      지원자 to 영화사에서 영화사 to 지원자로 의존성의 역전
      

  • Event Driven: Event가 발생하면 정보 제공
  • Observer Pattern: 등록한 Observer에게 event 발생하면 정보 제공
  • Semaphore: OS에서 다시 다룰 예정
• Synchronous I/O
  • Polling: 궁금한 정보에 대해 계속 접근하는 것 -> 비싼 연산
  • Spinlock: OS에서 다시 다룰 예정
• Asynchronous I/O의 단점
  • 읽어올 정보가 거의 항상 있을 경우
    • Context switch로 인해 1초에 1000개 정도의 정보가 유실될 가능성이 있음
    • 실제로 메이플스토리의 경우, 네트워크를 Non-blocking의 Synchronous I/O로 구축
      
      

다음 주 까지의 assignment

• '공룡책(Operating System Concepts)' Chapter.05 까지 학습해오기
• 2주에 걸쳐 운영체제 학습하는 시간 가질 것임!

두다지 서버 개발자 양성 프로그램 Week 3

3번 째 멘토링

지난 주 과제로 Test case를 포함한 해시 테이블과 우선순위 큐를 다시 직접 작성하였고, 작성한 우선순위 큐를 활용하여 간단한 스케줄러 토이 프로젝트를 만들어 보았다. 이 때, 기본적으로 작성한 우선순위 큐를 곧바로 사용하는 것이 아니라, 작업 스케줄러로 사용하기 위해 특정 method를 변환해서 사용해야 한다는 등의 생각을 하며 기본 자료구조의 활용을 고민해볼 수 있었다. 그리고 상속이 가진 문제점을 시작으로 하여, 상속의 문제점을 회피하되 그 장점은 살리기 위한 방법의 일환으로 나온 Strategy Pattern에 대한 이야기를 멘토님과 나누었다. 혼자 이해를 하려고 했을 때는 왜, 그리고 어떻게 해당 디자인 패턴이 현업에서 사용될 수 있을지에 대한 확실한 이해를 할 수 없었지만, 멘토님의 라이브 코딩을 보며 Strategy Pattern이 이처럼 효율적으로 사용될 수 있음을 느낄 수 있었던 귀중한 시간이었다.

Code Review

• 현업에서의 코드 리뷰는 테스트 코드로 진행되는 것이 보통
• 한 class는 400 line 정도로 작성하는 것이 좋음
  • 한 method는 40 line, 한 프로그램은 1000 line 이상 넘기지 않는게 좋음!
• 화면 분할을 사용하는 프로그래머(ex. Vim user)들은 보통 한 파일에 몰아넣고 사용하는 경향이 있음
  • 반면에 파일을 쪼개서 작성하는 사람들도 있음. 즉, Case by case
• Code convention 익힌 다음에는 안전하게 Editor 내 reformatting 기능 사용하는 것이 좋음
  • 익숙해지기 전까지는 연습하면서 공부!
• python-fire(based on argparse) 등 잘 만들어진 module 사용
  • 핵심 Logic은 물론 본인이 구현해야 하지만, 다른 좋은 module을 같이 사용할 줄 아는 방법도 실력의 중요 요소
• 대개 main thread는 UI로 하고, 이외의 기능들은 추가적으로 thread 생성해주어 사용하는게 보통

feedback

• Class/method의 depth: prompt method 정도 길이로 작성하는 것이 딱 좋음
• 공부 및 과제에 시간 투자 더 하기..
  
  

Why Interface?

• 기계어로 모든 것을 작성하던 시절이 있었음...
  • 하나의 프로그램을 작성하는 것도 너무 어려움
• 고수준의 C언어 등장. C가 가진 Struct(구조체) 개념
  • 사람의 생각과 직관을 실현시킬 수 있도록 만족시켜준 개념이자,
  • 서로 다른 크기의 메모리를 하나의 구조체에 담아 관리하는 것은 획기적인 개념
  • but, C언어 사용자들의 무분별한 goto문 분기로 인한 코드의 스파게티화가 문제가 됨
• 함수로 가자!: 함수 단위로 packing 되어 내부에서 정돈되는 느낌
  • 프로그램은 사실 크게 보면 메모리와 메모리를 수정하려는 함수로 구성된 것임
  • 그러나, 함수 역시 모든 사람이 메모리를 접근하는 것에 대한 불만
• Class 개념의 등장
  • 클래스의 특징: Class 내에 method와 멤버 변수가 존재
  • 기본적으로는 class 내에서 사용이 가능
    • 권한에 대한 문제: public, protected, private...
  • Heap에 형성된 메모리를 누구에게 사용 가능하게 할 것인지에 대한 강제성 및 규칙 부여 가능 -> encapsulation
  • 함수로 공동의 데이터를 고쳐나가는 것에서 Class로 자신에게 주어진 권한의 영역만을 사용하는 패러다임으로의 변화
• 함수의 재사용: 상속을 통해 기존의 작성된 함수를 재사용해보면 어떨까?
  • ex) 개와 고양이의 '사료먹기'라는 행위

  Animal - Dog / Cat과 같이 작성하여 중복 메소드의 제거 가능
  

  • 상속이 없다면? 비슷한 작업을 하는데 계속해서 중복된 코드를 작성해야 함
  • 그러나, 상속이 남용됨에 따라 그 depth가 깊어지고 결과적으로 정신이 없어짐...
• Interface의 등장으로 사람들은 상속을 멀리하기 시작함
  • 나에게 필요한 정보가 산재되어있는가?(Class) / 나에게 필요한 정보가 잘 정돈되어있는가?(Interface)
  • 실제로 Depth가 깊어진 상속 구조에서 method를 Override할 때, 하나의 오타라도 나면 해당 코드는 작동하지 않아야 하는데 작동되는 경우가 생김
  • 즉, 점점 구조적 어려움으로 오류를 찾기가 어려워짐
• Interface라는 하나의 Summary note를 통해 주어진 기능들을 일목요연하게 보여주면 사용자의 이해를 돕고, 일종의 강제성도 부여할 수 있게 됨
  • 특정 행동에 대한 강제는 하지만, 그 내부적 구현은 해당 Interface를 사용하는 Class의 특성에 따라 다르게 설정할 수 있음
    • ex) Queue / Priority Queue / Circular Queue의 Interface: peek, pop, push의 methods
    • ex) Scheduler (Priority Scheduler / Round Robin Scheduler)의 Interface: add, delete, peek, pop의 methods
• Interface를 자체적으로 지원 안하는 인터프리터 언어를 사용하는 개발자들도 Class를 Interface와 같이 사용하는 경우가 많아지고 있음
• method 구현과 관련한 부분을 외부에서 넣어주는 것이 Strategy Pattern
  • 상황에 따라 바꾸어 사용할 수 있는 것이 Strategy!
  • 그러나 같은 method가 반복된다? 그냥 코드의 재사용으로 인정(아래 예제의 dummy_action 참조)
    • 상속으로 중복 method를 받아오게 되면 다시 그 method가 어느 부모 클래스에 속하는지 모르는 상속의 문제 발생
• Java의 Decorator Pattern 역시 본질은 Interface의 구현과 관련된 문제
  • Interface를 어떻게 사용하는 것에 따라 달라지는 것이 Design Pattern
• Strategy Patter의 예

def dummy_action():
    print('do a job')


class IEvent:
    def __init__(self):
        pass

    def run(self):
        assert False


class BackupPolicy(IEvent):
    def __init__(self):
        pass

    def run(self):
        dummy_action()


class ReportPolicy(IEvent):
    def __init__(self):
        pass

    def run(self):
        dummy_action()


class ISchedulePolicy:
    def __init__(self):
        pass

    def has_target(self):
        assert False

    def pop(self):
        assert False

    def add(self):
        assert False


class RoundRobinSchedulePolicy(ISchedulePolicy):
    def __init__(self):
        pass

    def has_target(self):
        # TODO
        pass

    def pop(self):
        # TODO
        pass

    def add(self):
        # TODO
        pass


class PriorityQueuePolicy(ISchedulePolicy):
    def __init__(self):
        pass

    def has_target(self):
        # TODO
        pass

    def pop(self):
        # TODO
        pass

    def add(self):
        # TODO
        pass


class Scheduler(object):
    def __init__(self, schedule_policy):
        self.schedule_policy = schedule_policy

    def loop(self):
        sp = self.schedule_policy
        while True:
            if sp.has_target():
                event = sp.pop()
                event.run()

    def add(self, event):
        sp = self.schedule_policy
        sp.add(event)


if __name__ == "__main__":
    # schedule_policy = RoundRobinSchedulePolicy()
    schedule_policy = PriorityQueuePolicy()
    Scheduler(schedule_policy).loop()

Computer Architecture - Pipeline

• 메인 보드의 Clock에 맞추어 Task들이 동작
• 파이프 라이닝은 일종의 컨베이어 벨트화
  • 각각의 독립된 Core에 To-do list를 전달
  • 하나의 Core는 주어진 하나의 일만 끝내고 쉬는 것이 아니라 부여받은 List의 일을 계속해서 수행
  • 이론적상으론 Core 갯수만큼의 성능 향상 얻을 수 있음
    • 마냥 행복할 수는 없음: Pipeline Hazard
• 각 Core는 완료한 작업을 넘길 수 있는 매개체가 있어야 함(Memory, disk...)
• Core에서 끝난 각 Task를 다음 Core에게 direct하게 넘기는게 아니라, Queue 구조를 사용하는 것이 일반적
  • Direct하게 전달할 시, 속도에 따른 불균형이 생길 수 있기 때문
• 단순히 CA의 개념에서 그치는 것이 아니라 실제로 Scrapy와 같은 소프트웨어에서도 파이프라이닝 사용
  • 기본 개념을 알면 실생활에서 '이렇게도 사용할 수 있지 않을까?'라는 생각을 할 수 있게 됨
    
    

다음 주 까지의 assignment

• Cache, Pipeline, I/O interrupt, 시스템 버스 학습해오기 from <컴퓨터구조론>
• <리눅스 커맨드 라인 완벽 입문서> 읽고, 중요 개념 정리하기
• vim 익히기
  • Tool에 익숙해야 내 실력을 온전히 발휘할 수 있음

쉘 학습(2)

리다이렉션

표준 입출력과 표준 오류

• 출력은 두 가지 형식을 포함
  1. 프로그램의 결과. 즉, 프로그램이 출력하도록 설계한 데이터
  2. 프로그램이 어떻게 돌아가고 있는지를 말해주는 상태 및 오류 메시지 형식
• I/O 리다이렉션 기능으로 출력과 입력의 방향 변경 가능

표준 출력 재지정

• 화면에 출력하는 대신 다른 파일에 출력하도록 할 수 있음
• 명령어 출력결과를 파일에 저장하는 것이 종종 유용하기 때문

ls -l /usr/bin > ls-output.txt

• > 리다이렉션 연산자로 출력 방향을 지정할 때, 목적 파일은 항상 처음부터 다시 작성됨

• 이러한 트릭을 이용하여 빈 파일을 만드는 방법

> ls-output.txt

• >> 리다이렉션 연산자를 사용하여 파일에 이어 쓰기가 가능해짐

표준 오류 재지정

• 표준 오류 재지정할 때는 리다이렉션 연산자가 필요 없음
• 파일 디스크립터를 참조
  • 0, 1, 2번 파일 디스크립터
  • 순서대로 표준 입력, 표준 출력 , 표준 오류

ls -l /bin/usr 2> le-error.txt

표준 출력과 표준 오류를 한 파일로 재지정

ls -l /bin/usr &> ls-output.txt

• &> 표기가 표준 출력과 표준 오류를 함께 재지정해주는 역할

원치 않는 출력 제거

• /dev/null 이라는 특수한 파일로 출력 방향을 지정함으로써 출력 결과 버릴 수 있음
• 비트 버킷이라고 불리는 시스템 장치로 입력을 받고 아무것도 수행하지 않음

표준 입력 재지정

파일 붙이기

• cat 명령어는 하나 이상의 파일을 읽어 들여서 표준 출력으로 그 내용을 복사
• 주로 짧은 텍스트 파일을 표시하거나, 파일을 하나로 합치는 데에도 사용 가능

[me@linuxbox~] cat
The quick fox jumped.
The quick fox jumped. // CTRL + D 눌러 EOF 문자 입력

[me@linuxbox~] cat > lazy_dog.txt
The quick fox jumped.
// CTRL + D 눌러 EOF 문자 입력

[me@linuxbox~]cat lazy_dog.txt
[me@linuxbox~]cat < lazy_dog.txt
는 똑같은 기능 수행

파이프라인

• command1 | command2를 활용하여 표준 출력을 표준 입력으로 활용 가능

ls -l /usr/bin | less

필터

• 파이프라인은 데이터의 복잡한 연산을 수행할 때 종종 사용
• 하나의 파이프라인에 여러 명령어의 입력이 가능

ls /bin /usr/bin | sort | less
// 두 디렉토리에 있는 실행 프로그램들을 하나의 목록으로 만들어 정렬한 뒤 보여줌

중복줄 제거 및 표시

• uniq 명령어는 종종 sort와 함께 사용

# 중복된 내용을 제거해서 보고자 할 때
ls /bin /usr/bin | sort | uniq | less
# 중복된 내용만 보고자 할 때 
ls /bin /usr/bin | sort | uniq -d | less

라인, 단어 개수 및 파일 크기 출력

• wc 명령어는 파일에 들어있는 라인 - 단어 - 파일 크기의 순으로 출력

wc file.txt

• -l 옵션은 라인 수만 보고 싶을 때 사용 가능

# 정렬된 목록의 항목 개수를 알고 싶을 때 사용
ls /bin /usr/bin | sort | uniq | wc -l

패턴과 일치하는 라인 출력

• grep 명령어는 파일 내에서 "패턴"을 만났을 때, 그 패턴을 가지고 있는 라인을 출력
  • grep pattern [file...]

ls /bin /usr/bin | sort | uniq | grep zip

• -i 옵션은 검색 수행할 때 대소문자 구분하지 않도록 함
• -v 옵션은 패턴과 일치하지 않는 라인만 출력

파일의 처음/끝 부분 출력

• head, tail 명령어로 첫 / 마지막 10줄 표시 가능
• head(tail) -n #로 그 수 조정 가능
• tail에 -f 옵션 지정하면, 실시간으로 파일 확인 가능

tail -f /var/log/messages

표준 입력에서 데이터 읽고, 표준 출력과 파일에 출력

• tee 프로그램은 표준 입력으로부터 데이터를 읽어서 표준 출력과 하나 이상의 다른 파일에 동시에 출력
• 작업이 진행되고 있을 때, 중간 지점의 파이프라인에 있는 내용을 알고 싶을 때 유용

ls /usr/bin | tee ls.txt | grep zip

확장과 인용

확장

• 쉘은 명령어가 실행되기 직전에 모든 한정 문자들을 한정

• 위 그림에서 쉘은 * 기호를 확장시킨 후, 디렉토리의 이름으로 확장하여 보여주었음

경로명 확장

echo D*
echo *s
echo /usr/*/share

틸드 확장

# 현재 사용자의 홈 디렉토리명
echo ~

# foo 계정의 홈 디렉토리명
echo ~foo

산술 확장

• &((expression)) 으로 산술 확장 사용 가능

echo $(((5**2) *3))

중괄호 확장

• 중괄호 안에 표현된 패턴과 일치하는 다양한 텍스트 문자열 생성 가능

• 위와 같이 정렬된 디렉토리 생성에 아주 유용하게 사용 가능

매개변수 확장

• 매개변수를 확장해서 볼 수 있음
• ex) echo $USER
• 사용 가능한 변수 목록 보기
  • printenv | less

명령어 치환

• 명령어 치환으로 명령어의 출력 결과를 확장해서 사용 가능
  • ex) echo $(ls)

따옴표 활용(Quoting)

따옴표 기호를 활용하여 원치 않는 확장을 선택적으로 감출 수 있음

쌍 따옴표 기호

• 쌍 따옴표 기호를 이용하여 원치 않는 단어 분할 문제 해결 가능

• 쌍 따옴표가 사용되면, 커맨드라인에서 하나의 명령 인자로 처리
  • 첫 번째 입력은 38개의 명령 인자를 가진 명령어로 인식
  • 두 번째 입력은 빈칸과 개행 문자 포함하여 하나의 명령 인자로 인식

따옴표 기호

• 모든 확장을 숨겨야 한다면 따옴표 기호 사용

이스케이프 문자

• 종종 선택적으로 확장을 막기 위해 쌍 따옴표 안에서 사용
• 또한 파일명에 있는 어떤 문자가 가진 특별한 의미를 없애고 싶을 때 흔히 사용
  
  

고급 키보드 기법

커맨드라인 편집

커서 이동

• CTRL + A: 줄 맨 앞으로 커서 이동
• CTRL + E: 줄 맨 끝으로 커서 이동
• ALT + F: 다음 한 단어로 커서 이동
• ALT + B: 이전 한 단어로 커서 이동

텍스트 수정

• CTRL + T: 현재 커서 위치에 있는 글자와 바로 앞글자의 위치 바꾸기
• ALT + T: 현재 커서 위치에 있는 단어와 바로 앞 단어의 위치 바꾸기
• ALT + L: 현재 커서 위치에 있는 글자부터 그 단어 끝 부분까지 소문자로 바꾸기
• ALT + U: 현재 커서 위치에 있는 글자부터 그 단어 끝 부분까지 대문자로 바꾸기

• CTRL + K: 현재 커서 위치로부터 그 줄 끝 부분까지 텍스트 지우기
• CTRL + U: 현재 커서 위치로부터 그 줄 처음 부분까지 텍스트 지우기
• ALT + D: 현재 커서 위치에서부터 그 단어 끝 부분까지 텍스트 지우기
• ALT + BACKSPACE: 현재 커서 위치에서부터 그 단어 앞부분까지 텍스트 삭제하기
• CTRL + Y: 잘라낸 데이터는 kill-ring이라고 하는 버퍼에 저장되는데, kill-ring에 있는 텍스트를 현재 커서 위치에 삽입

히스토리 활용

• bash는 입력된 명령어에 대한 히스토리를 저장
• 히스토리는 홈 디렉토리에 .bash_history라는 파일로 저장

히스토리 검색

• 기본값으로 bash는 사용자가 입력한 최근 500개의 명령어 저장

• 출력 결과 중 필요한 명령어가 포함된 줄만을 찾을 수도 있음
  • 이후 !line_number로 해당 명령어 재실행 가능
• CTRL + R: 역순 증분 검색으로, 현재 커맨드라인에서 히스토리 목록으로 증분 검색
  • bash에 명령을 주면 각 글자가 추가될 때마다 우리가 원하는 검색 결과를 골라서 보여줌
  • 원하는 결과를 찾으면 CTRL + J를 눌러 현재 커맨드라인에 그 명령어 복사 가능

히스토리 확장

• !!: 마지막 명령어를 반복하여 실행
• !string: 이 문자열로 시작하는 가장 최근에 입력된 항목 실행
• !?string: 이 문자열이 포함된 가장 최근에 입력된 항목을 실행
  
  

퍼미션

소유자, 그룹 멤버, 기타 사용자

• id 명령어 통해 자신의 사용자 ID 정보 확인 가능
• 사용자 ID(uid)와 주 그룹 ID(gid) 존재
• 사용자 계정은 /etc/passwd 파일에 정의
• 그룹은 /etc/group 파일에 저으이
• 사용자 계정과 그룹이 생성되면, 이 파일들은 사용자 비밀번호에 관한 정보를 가진 /etc/shadow에 덧붙여 수정

파일 모드 변경

8진법 표현

• 0: ---  1: --x  2: -w-  3: -wx  4: r--
• 5: r-x  6: rw-  7: rwx

기호 표현

• u: user의 약자로, 파일이나 디렉토리 소유자

• g: 그룹 소유자

• o: othres의 약자로, 기타 사용자

• a: all의 약자로, u,g,o의 조합

• chmod 기호 표기법 예제

  • u+x: 소유자에게 실행 권한 추가
  • u-x: 소유자에게 실행 권한 제거
  • +x: 모든 사용자에게 실행 권한 추가
  • go=rw: 그룹 소유자와 기타 사용자가 읽기, 쓰기 권한을 갖도록 함

기본 권한 설정

• 파일 모드 속성에서 제거할 비트 마스크를 표현하는 umask 설정
• 일반적인 umask의 기본 값은 0002 혹은 0022

사용자 ID 변경

다른 사용자 ID와 그룹 ID로 쉘 실행

• su - 명령어로 슈퍼유저로 쉘 시작 가능
• su -c 'command': 새로운 명령어로 시작하지 않고 단일 명령어 수행 가능

다른 사용자로 명령어 실행

• 사용자는 하나 이상의 지정된 명령어로 제한되고 나머지는 불가
• sudo -l: sudo로 허용된 특권을 확인하기 위한 옵션
• sudo는 슈퍼유저의 비밀번호를 요구하지 않음

파일 소유자와 그룹 변경

• chown [owner][:[group]] file...
• chown 인자 예제
  • bob: 파일 소유자를 bob으로 변경
  • bob:users: 파일 소유자를 bob으로 변경하고, 파일 그룹 소유자를 users 그룹으로 변경
  • :admins: 파일 그룹 소유자만 admins 그룹으로 변경
  • bob::파일 소유자가 bob으로 변경되고 그룹 소유자는 bob의 로그인 그룹으로 변경

사용자 비밀번호 변경

• passwd [user] 명령어 통해 자신의 비밀번호 변경 가능
• 슈퍼유저 특권을 가지고 있다면 첫 번째 인자에 사용자 이름을 지정해서 해당 사용자의 비밀번호 설정 가능
  
  

프로세스

프로세스는 어떻게 동작하는가

• 시스템이 구동될 때, 커널은 몇몇 프로세스를 초기화하고 init이라는 프로그램 실행
• init은 차례차례 모든 시스템 서비스를 시작하기 위해 init 스크립트라고 불리는 쉘 스크립트 실행

ps 명령어로 프로세스 보기

• 프로세스를 보는 가장 일반적인 명령어는 ps
• tty(teletype): 프로세스용 제어 터미널

• ps aux 명령어로 모든 프로세스를 보여줌
• 프로세스 상태
  • R: 실행 상태
  • S: 수면 상태
  • D: 인터럽트 불가능한 수면 상태
  • T: 종료 상태
  • Z: 좀비 프로세스
  • <: 높은 우선순위 프로세스
  • N: 낮은 우선순위 프로세스
• ps 헤더들
  • USER: 사용자 ID
  • %CPU: CPU 사용량
  • %MEM: 메모리 사용량
  • VSZ: 가상 메모리 크기
  • RSS: 사용 메모리 크기
  • START: 프로세스가 시작된 시각

top 명령어로 프로세스 변화 보기

• top 프로그램은 프로세스가 활동순으로 나열된 시스템 프로세스들을 지속적으로 갱신하여 보여줌
• 시스템상의 최상위 프로세스들을 보기 위해 사용
• top 정보 필드
  • up 19days: 시스템이 마지막 부팅된 시점부터 지금까지의 시간
  • 1 users: 로그인한 사용자의 수
  • load average: 평균부하는 실행 대기중인 프로세스 수 의미
  • Tasks: 프로세스 수와 프로세스 상태별 수
  • 0.0 us: CPU의 0.0%를 사용자 프로세스들이 사용 중
  • 0.0 sy: CPU의 0.0%를 시스템(커널) 프로세스에서 사용 중
  • 0.0 ni: CPU의 0.0%를 nice 프로세스가 사용 중
  • 100.0 id: CPU의 100.0%가 유휴 상태
  • 0.0 wa: CPU의 0.0%가 I/O 대기 중
  • Mem: 물리메모리 사용현황
  • Swap: 스왑 영역(가상 메모리) 사용현황

프로세스를 백그라운드로 전환

• & 기호를 사용하여 프로그램을 백그라운드로 이동 가능
• jobs 명령어는 터미널에 실행 중인 작업을 나열해주는 기능
  • jobs에서 지정한 작업 번호(jobspec)을 이용하여 fg로 재전환 가능
  • ex) fg %1

프로세스 정지(일시정지)

• 포어그라운드 프로세스를 정지하기 위해서는 CTRL+Z를 누름
• 이후, fg 명령어로 프로그램을 포어그라운드로 복원하거나, bg 명령어로 프로그램을 백그라운드로 이동 가능
  • ex) bg %1

시그널

• kill 명령어는 프로세스를 종료하는 것이 아니라, 프로세스에 시그널을 보내는 것

kill로 시그널 보내기

• kill [-signal] PID ...
• 커맨드라인에 지정된 시그널이 없다면, 기본적으로 종료 시그널을 보냄
• 주요 시그널
  • 1(HUP): 제어 터미널과 연결이 끊어진 프로그램을 가리키는데 사용
  • 2(INT): Interrupt. 터미널에서 CTRL+C 키를 보낸 것과 동일한 기능
  • 9(KILL): 커널이 프로세스를 즉시 종료. KILL 시그널은 마지막 수단으로 사용되어야 함(진행 중 작업 저장할 기회가 없음)
  • 15(TERM): 프로그램이 시그널을 받을 수 있을 정도로 "살아있다면" 프로그램은 이 시그널을 받고 종료됨
  • 18(CONT): STO 시그널로 정지된 프로세스 복원
  • 19(STOP): 프로세스를 종료 없이 일시 정지 시킴
• kill 명령어로 프로세스에 시그널을 보내려면 반드시 그 프로세스의 소유자이거나 슈퍼유저여야 함
• 그 외 주요 시그널
  • 3(QUIT): Quit. 사용자가 종료 키를 입력하면 커널이 프로세스에 SIGQUIT 시그널 보냄
  • 11(SEGV): 프로그램이 잘못된 메모리 사용이 이뤄질 때 보내짐
  • 20(TSTP): CTRL+Z를 눌렀을 때 터미널에 의해 보내짐
  • 28 (WINCH): 윈도우 크기가 변경된 경우 시스템에 보내짐
• killall로 다수의 프로세스에 시그널을 보낼 수도 있음
  • killall [-u user] [-signal] name ...

기타 프로세스 관련 명령어들

• pstree: 프로세스 간의 부모/자식 관계를 보여주는 트리 형태로 정렬해서 프로세스 목록 출력

• vmstat: 메모리, 스왑, 디스크 I/O를 포함한 시스템 자원 사용 현황 출력
• xload: 시간에 따라 시스템 부하를 그래프로 보여주는 그래픽 프로그램
• tload: xload 프로그램과 유사하지만 터미널에서 그래프 보여줌

Vim tutor (ver. 1.7) 정리

Lesson 1

1.1. MOVING THE CURSOR

• h, j, k, l 키로 커서 이동 가능
• h는 좌측으로 이동 / l은 우측으로 이동
• j는 아래로 이동 / k는 위로 이동
• 화살표 키도 같은 원리로 동작하지만, hjkl을 사용하는 것이 익숙해지면 더 좋은 성능을 보임

1.2. EXITING VIM

1. 키를 통해 Normal mode로 전환
2. Type :q!
   • q!를 이용한 종료는 수정 내역을 모두 무시하는 종료

1.3. TEXT EDITING - DELETION

• x키를 사용하여 cursor가 표시하고 있는 문자 삭제 가능

1.4. TEXT EDITING - INSERTION

1. Normal mode에서 Insert Mode로 전환하기 위해 [i] 누름
2. cursor 왼쪽에 문자 추가 가능

1.5. TEXT EDITING - APPENDING

1. Normal mode에서 Insert Mode로 [a]를 눌러 전환
2. cursor가 표시하고 있는 오른쪽부터 문자 추가 가능

1.6. EDITING A FILE

• :wq : 수정 사항을 반영하여 파일을 저장한 후 종료
  
  

Lesson 2

2.1. DELETION COMMANDS

• Normal mode에서 dw 명령어 사용하여 단어 단위로 삭제 가능
• Normal mode에서 dd 명령어 사용하여 line 단위로 삭제 가능

2.2. ON OPERATORS AND MOTIONS

• w: 다음 단어의 첫 글자로 이동
• e: 다음 단어의 마지막 글자로 이동
• $: line의 맨 마지막 글자로 이동

2.3. USING A COUNT FOR A MOTION

• 2w, 3e 등 숫자를 활용한 이동 또한 가능
• 0 입력해서 line의 처음으로 이동 가능

2.4. USING A COUNT TO DELETE MORE

• d2w, d3w 등으로 단어 여러 개 동시에 삭제도 가능

2.5. THE UNDO COMMAND

• u 입력하여 마지막 명령 취소 가능
• U 입력하여 전체 라인에 대한 수정 취소 가능
  
  

Lesson 3

3.1. THE PUT COMMAND

• 무언가를 지우면 Vim register에 저장됨
• 이를 이용하여 삭제한 특정 line을 p 입력으로 커서 아래에 붙여넣기 가능

3.2. THE REPLACE COMMAND

• r + <바꿀 글자> 명령어로 커서 아래 글자의 변경 가능

3.3. THE CHANGE OPERATOR

• ce 입력하여 커서 뒤 글자들 제거 가능
• 제거 이후 사용자를 Insert mode에 위치시킴
• Deletion 때와 마찬가지로 cw, c$ 등의 명령어도 적용이 가능
  
  

Lesson 4

4.1. CURSOR LOCATION AND FILE STATUS

• CTRL-G: 현재 자신이 보고있는 파일의 위치와 상태 표시
• gg: 파일의 맨 처음 line으로 이동
• G: 파일의 맨 마지막 line으로 이동
• line # + G: 해당 line 번호로 이동

4.2. THE SEARCH COMMAND

• / 누른 후 원하는 검색어 입력하여 검색 가능(커서 다음부터 검색)
• ? 누른 후 원하는 검색어 입력하여 검색 가능(커서 이전부터 검색)
• n: 다음 검색 결과 확인 가능
• N: 이전 검색 결과 확인 가능
• CTRL-O: 검색 이전에 있던 장소로 돌아가기
• CTRL-I: 다음 장소로 이동

4.3. MATCHING PARENTHESES SEARCH

• 커서를 (, [, { 위에 올려놓고 % 입력
• 닫히는 괄호를 찾아주는 기능 수행
• 괄호가 안맞는 프로그램을 디버깅할 때 매우 유용하게 사용 가능

4.4. THE SUBSTITUTE COMMAND

• :s/old/new: line 내 첫 번째 old를 new로 교체
• :s/old/new/g: line 내 모든 old를 new로 교체
• :%s/old/new/g: 파일 내 모든 old를 new로 교체
• :%s/old/new/gc: 파일 내 모든 old를 new로 교체하되, 매 번 확인 여부 물음
• :#,#s/old/new/g: 두 line 번호 사이에 있는 모든 old를 new로 교체
  
  

Lesson 5

5.1. HOW TO EXECUTE AN EXTERNAL COMMAND

• :! 이후에 external command를 입력하여 외부 명령어 실행 가능

5.2. MORE ON WRITING FILES

• :w file_name 으로 다른 이름으로 저장 가능

5.3. SELECTIONG TEXT TO WRITE

• v 눌러서 Visual mode로 진입
• 커서 옮겨서 처리하고 싶은 line들 highlighted 되게 설정
• :누르면 :'<,'> 를 확인 가능

:'<,'>w TEST

5.4. RETRIEVING AND MERGING FILES

• r 명령어 통해 파일 읽어와 현재 파일의 커서에 붙여넣기 가능

:r FILENAME

# 아래와 같은 응용도 가능
:r !ls

Lesson 6

6.1. THE OPEN COMMAND

• o: 커서 아래에 한 공백 line을 추가하고 사용자를 Insert mode에 진입시킴
• O: 커서 위에 한 공백 line을 추가하고 사용자를 Insert mode에 진입시킴

6.2. THE APPEND COMMAND

• a: 커서 다음에 새로운 글자 추가하도록 함
• A: line 마지막에 새로운 글자 추가하도록 함

6.3. ANOTHER WAY TO REPLACE

• R: Replace mode로 진입
• 입력한 글자가 이미 존재하는 글자들 지우는 형태의 모드

6.4. COPY AND PASTE TEXT

• v 눌러 Visual mode 진입한 후, y 버튼으로 highlighted 된 문장 복사 가능
• p 눌러 복사한 문장 붙여넣기 가능
• yw: 한 단어 복사
• V: line 단위로 Visual mode highlight

6.5. SET OPTION

• :set ic: 대소문자 구분 없이 검색 가능하게 하는 옵션
• :set noic: ic 옵션 비활성화
• :set hls: 모든 검색 결과 highlight 되도록 하는 옵션
• :nohlsearch: 검색 결과 highlight 제거
• :set is: 부분 매칭되는 결과도 함께 보여주도록 하는 옵션
• 옵션의 앞에 'no' 붙이면 옵션 해제 가능
  
  

Lesson 7

7.1. GETTING HELP

• [F1] 키 or :help 입력해서 도움 시스템 실행 가능
• CTRL + W 눌러 서로 다른 창 이동 가능

7.2 CREATE A STARTUP SCRIPT

• vimrc 파일 수정해서 원하는 옵션 추가하여 사용 가능
  • 위치: ~/.vimrc
• :r $VIMRUNTIME/vimrc_example.vim
  • 코드 파일 syntax highlight 기능 추가!

7.3 COMPLETION

• : 누르고 문자 입력한 후, CTRL + D 입력하면 해당 문자로 시작하는 명령어 목록 보여줌
• 키로 명령어 자동완성 기능 사용 가능

폰 노이만 아키텍쳐

• EDVAC 컴퓨터에 대한 보고서에서 처음으로 등장 아키텍쳐

• 폰 노이만 아키텍쳐 컴퓨터의 구성 요소
  • ALU와 프로세서 레지스터를 지닌 CPU
  • 명령어 레지스터와 PC를 가진 제어 유닛
  • 데이터와 명령어를 저장하는 주기억장치
  • 큰 용량의 외부 보조기억장치
  • I/O 메커니즘
• 폰 노이만 아키텍쳐는 점차 '프로그램 내장식 컴퓨터(stored-program computer)' 라는 단어로 진화
  • Instruction fetch와 Data operation이 동시에 일어나지 않아야 함
  • 그 둘은 같은 System bus를 공유하기 때문
  • 이러한 특성으로 인해 폰 노이만 병목 현상이 발생되어, 종종 성능 저하 발생
• 폰 노이만 아키텍쳐와 하버드 아키텍쳐의 가장 큰 차이는 Main memory가 아닌 캐시 아키텍쳐에 적용됨(분산 캐시 구조)
  
  

폰 노이만 병목 현상

• 프로그램 메모리와 데이터 메모리를 공유하는 시스템 버스는 폰 노이만 병목 현상을 야기함
  • CPU와 메모리 사이의 제한된 데이터 전송률로 인해 발생
• 하나의 버스는 프로그램 메모리, 데이터 메모리 중 하나의 메모리에만 접근 가능하기 때문에, throughput이 CPU의 작업 속도에 한참 미치지 못함
• 특히, 적은 CPU 사용에 많은 양의 데이터를 필요로 할 때 그 성능 저하가 극에 달하게 됨

병목 현상 완화 방안

1. CPU와 Main memory 사이에 cache 설치
2. 분리된 캐시 혹은 명렁어와 데이터에 분산된 접근을 사용(so-called Modified Harvard architecture)
3. 분기 예측 알고리즘과 로직을 사용
4. 메모리 접근 횟수를 줄이기 위해 제한된 수의 CPU 스택 혹은 다른 on-chip Local memory를 사용

기억장치

• 모든 컴퓨터시스템들은 프로그램과 데이터를 저장하기 위한 장치로서 주기억 장치와 보조저장장치를 가지고 있음
• 기억장치는 CPU가 직접 액세스할 수 있는 내부 기억장치와 장치 제어기를 통하여 액세스할 수 있는 외부 기억장치로 구성

1. 기억장치의 분류와 특성

• CPU가 어떤 정보를 기억장치에 쓰거나 기억장치로부터 읽는 동작을 액세스한다고 말함
• 기억장치의 액세스 유형
  1. 순차적 액세스: 기억장치에 저장된 정보들을 처음부터 순서대로 액세스. 정보가 저장된 위치에 따라 액세스 시간이 달라짐
  2. 직접 액세스: 읽기/쓰기 장치를 정보가 위치한 근처로 직접 이동시킨 다음에, 순차적 검색으로 최종 위치에 도달하여 액세스 하는 방식
  3. 임의 액세스: 기억 장소들이 임의로 선택될 수 있으며, 기억장치 내의 어떤 위치든 동일한 액세스 시간이 걸리는 방식
  4. 연관 액세스: 각 기억 장소에 포함된 key값의 검색을 통하여 액세스할 위치를 찾아내는 방식
• 기억장치 시스템을 설계하는 데 있어 고려해야 할 주요 특성은 용량과 액세스 속도
• 기억장치에서 용량을 나타내는 단위는 바이트(byte) 혹은 단어(word)
• 전송 단위: CPU가 한 번의 기억장치 액세스에 의해 읽거나 쓸 수 있는 비트 수
  • 외부 기억장치에서는 데이터가 단어보다 훨씬 큰 단위로 전송되기도 하는데, 그 단위를 블록이라 부름
• 주소지정 단위: 하나의 주소에 의해 액세스되는 비트들의 그룹
• 액세스 속도와 관련된 파라미터
  • 액세스 시간: 주소와 읽기/쓰기 신호가 기억장치에 도착한 순간부터 데이터가 저장되거나 읽혀지는 동작이 완료될 때 까지의 시간
  • 기억장치 사이클 시간: 액세스 시간과 데이터 복원 시간을 합한 시간
  • 데이터 전송률: 기억장치로부터 초당 읽혀지거나 쓰여질 수 있는 비트 수
    • (1/액세스 시간) X (한 번에 읽혀지는 데이터 바이트의 수)
• 휘발성 기억장치: 전력공급이 중단되면 저장된 내요이 사라지는 기억장치
• 비휘발성 기억장치: 전력공급이 중단되어도 저장된 내용이 그대로 유지되는 기억장치
  
  

2. 계층적 기억장치시스템

• 기억장치들은 유형에 따라 기능, 속도, 용량 및 가격이 매우 다양
• 컴퓨터시스템에서는 여러 유형의 기억장치들을 계층적으로 구성하여 설치함으로써, 평균 기억장치 액세스 속도를 높이면서 가격대비 성능비도 적절히 유지되도록 하는 계층적 기억장치시스템을 구성함

2-1. 필요성 및 효과

• 액세스 속도가 높아질수록, 비트당 가격도 높아짐
• 용량이 커질수록 비트당 가격은 낮아짐
• 용량이 커질수록 액세스 속도는 낮아짐
• 지역성의 원리: CPU가 기억장치의 한정된 몇몇 영역들을 집중적으로 액세스하면서 작업을 수행한다는 원리
• 지역성의 원리로 인해 계층적 기억장치시스템의 효율이 극대화되게 됨

2-2. 기억장치 계층

• 상위 기억장치 계층으로 올라갈수록...
  • 비트당 가격이 높아지고,
  • 용량이 감소하며,
  • 액세스 시간은 짧아지고,
  • CPU에 의한 액세스 빈도는 높아짐
• 내부 기억장치: CPU 레지스터 - 캐시 - 주기억장치
• 외부 기억장치(by. 장치 제어기): 디스크 캐시 - 디스크 - 자기 테이프 및 CD-ROM
  • 주로 프로그램 파일들과 데이터 파일들이 저장되며, 바이트나 단어 단위가 아닌 블록이나 레코드 단위로 액세스 가능
• 하위 계층으로 내려갈수록 용량이 더 커지고 비트당 가격은 떨어지는 반면에, 지역성의 원리로 인하여 액세스 빈도가 더 낮아짐
  
  

3. 캐시 메모리

• CPU와 주기억장치의 속도 차이를 보완하기 위하여 그 사이에 설치하는 반도체 기억장치
• CPU가 원하는 데이터가 이미 캐시에 적재되어 있는 상태가 캐시 적중(cache hit)
• CPU가 원하는 데이터가 캐시에 없는 상태는 캐시 미스(cache miss)
• 캐시 적중률: H = 캐시에 적중되는 횟수 / 전체기억장치 액세스 횟수
  • 캐시 미스율 = 1 - H
• 평균 기억장치 액세스 시간, Ta = H x Tc + (1-H) x Tm
  • Tc: 캐시 액세스 시간
  • Tm: 주기억장치 액세스 시간
• 지역성의 종류
  • 시간적 지역성: 최근에 액세스된 프로그램 코드나 데이터가 가까운 미래에 다시 액세스될 가능성이 높아지는 특성
  • 공간적 지역성: 기억장치 내에 서로 인접하여 저장되어 있는 데이터들이 연속적으로 액세스될 가능성이 높아지는 특성
  • 순차적 지역성: 분기가 발생하지 않는 한, 명령어들은 기억장치에 저장된 순서대로 인출되어 실행됨
• 캐시 설계의 공통적 목표
  • 캐시 적중률의 극대화
  • 캐시 액세스 시간의 최소화
  • 캐시 실패에 따른 지연시간의 최소화
  • 주기억장치와 캐시간의 데이터 일관성 유지 및 그에 따른 오버헤드 최소화

3-1. 캐시 용량

• 캐시의 용량이 커질수록 적중률이 높아짐
• 그러나 비용도 같은 비율로 상승하기 때문에 캐시의 용량은 비용과의 상호조정을 통하여 적절히 결정해야 함

3-2. 인출 방식

• 요구 인출: 캐시 미스가 발생한 경우 CPU가 필요한 정보만 캐시로 인출해오는 방식
• 선인출: CPU가 필요한 정보 외에도 그와 인접해 있는 정보들을 함께 캐시로 인출해오는 방식
  • 주기억장치를 액세스할 때 함께 인출되는 정보들의 그룹을 블록이라 부름
• 캐시 라인: 주기억장치로부터 캐시로 인출되는 단위인 한 블록이 적재되는 캐시 내 공간
  • 캐시의 각 라인은 여러 개의 블록들에 의해 공유됨
  • 태그: 캐시 라인을 공유하는 블록들 중에서 어느 것이 적재되어 있는지를 가리키는 비트들

3-3. 사상 방식

• 주기억장치 블록이 어느 캐시 라인에 적재될 수 있는지를 결정해주는 알고리즘
• 캐시 적중률에 많은 영향을 미치는 주요 설계 요소

1) 직접 사상

• 주기억장치 블록이 지정된 어느 한 라인에만 적재될 수 있는 사상 방식
• 주기억장치의 블록 j가 적재될 수 있는 캐시 라인의 번호 i는 modulo 함수에 의해 결정
  • i = j % m(캐시 라인의 수)
• 캐시의 각 라인에는 태그와 데이터 블록이 함께 저장되며, 캐시 적중 여부는 주소의 태그 비트들과 라인에 저장된 태그 비트들을 비교함으로써 결정됨

2) 완전-연관 사상

• 주기억장치 블록이 캐시의 어느 라인으로든 적재될 수 있는 사상 방식
• 주기억장치 블록이 캐시의 어떤 레인에든 적재될 수 있으므로, 캐시 적중 여부를 검사할 때 캐시의 모든 라인들의 태귿르과 주기억장치 주소의 태그 필드 내용을 비교하여 일치하는 것이 있는 지 확인해야 함
  • 많은 수행시간이 걸릴 것이므로, 연관 기억장치 등을 이용하여 비교 동작이 병렬로 신속히 이루어질 수 있도록 구성해야 함
• 완전-연관 사상에서는 새로운 블록이 캐시로 적재될 때 라인의 선택이 자유롭기 때문에, 프로그램 세그먼트나 데이터 배열 전체가 캐시로 적재될 수 있음
  • 이 경우 만약 지역성이 높다면 적중률이 매우 높아질 것
• 그러나 모든 태그들을 병렬로 검사하기 위하여 복잡하고 비용이 높은 하드웨어를 포함해야 한다는 단점 때문에 실제로 거의 사용되지 않음

3) 세트-연관 사상

• 주기억장치 블록이 지정된 어느 한 세트로만 적재될 수 있으며, 각 세트는 두 개 이상의 라인들로 구성된 사상 방식
• 캐시는 v개의 세트들로 나누어지며, 각 세트는 k개의 라인들로 구성
• 주기억장치 블록이 적재될 수 있는 캐시 세트의 번호 i = j mod v
• 세트당 라인이 k개씩 있으면 k-way 세트-연관 사상
• 세트-연관 사상에서 세트의 수가 캐시 라인의 수가 같고(v=m), 세트 내 라인의 수 k=1이라면, 이 방식은 직접 사상과 같아짐
• 세트의 수 v=1이고, 세트 내 라인 수가 캐시의 전체 라인 수와 같다면(k=m), 완전-연관 사상에 해당
• 2-way 세트-연관 사상이 가장 보편적으로 사용되고 있는 세트-연관 조직
  • 직접 사상보다 적중률이 훨씬 높음
    
    

3-4. 교체 알고리즘

• 캐시 미스가 발생하여 새로운 블록이 주기억장치로부터 캐시로 올라왔을 때, 그 블록이 적재될 수 있는 라인들이 이미 다른 블록들로 채워져 있다면, 그 블록들 중의 하나는 교체되어야 함
• LRU(Least Recently Used) 알고리즘: 세트 라인에 적재되어 있는 블록들 중에서 최근의 사용 빈도가 가장 낮은 블록을 선택하여 교체하는 방식
• FIFO(First in First Out) 알고리즘: 캐시에 적재된 지 가장 오래된 블록을 교체하는 방식
• LFU(Least Frequently Used) 알고리즘: 캐시에 적재된 이래 사용된 빈도가 가장 낮은 블록을 교체하는 방식
• Random: 후보 라인들 중에서 한 라인을 임의로 선택하는 방식

3-5. 쓰기 정책

• 캐시에 적재되어 있는 데이터는 주기억장치에 있는 데이터의 복사본에 불과
• 따라서 캐시 데이터가 변경되면, 주기억장치에 있는 해당 데이터도 갱신하여 같은 값을 가지고 있도록 해야 함
• But, 캐시에서 데이터가 변경될 때마다 주기억장치에도 그 값을 갱신하면 기억장치 쓰기 시간이 그 만큼 더 길어짐
• 캐시의 라인을 교체할 때마다 해당 데이터가 캐시에 적재되어 있는 동안 '수정된'적이 있는 지를 확인
  • 수정된 적이 없다면, 그 데이터가 포함된 라인에 다른 블록 즉시 적재 가능
  • 수정된 적이 있다면, 수정된 데이터가 포함된 라인의 내용을 주기억장치의 해당 블록에 저장한 다음 새로운 블록을 적재
• 이와 같이 캐시에 적재된 데이터를 새로운 값으로 변경할 때 주기억장치에 갱신하는 시기와 방법을 결정하는 것이 쓰기 정책
  • write-through: 캐시에 쓰기 동작을 수행할 때 주기억장치에도 동시에 이루어지는 방식
    • 주기억장치의 내용들은 항상 유효하지만, 쓰기 동작에 걸리는 시간이 길어짐
  • write-back: 쓰기 동작이 캐시까지만 이루어지는 방식
    • 기억장치에 대한 쓰기 동작의 횟수가 최소화되고 쓰기 시간이 짧아짐
    • 그러나, 새로운 블록 적재 때 라인 데이터가 수정된 경우 주기억장치 갱신에 추가적 시간이 소요됨
    • 또한 캐시에서 수정된 내용이 갱신될 때까지 주기억장치의 해당 블록이 무효 상태에 있게 됨
    • 데이터 불일치 문제: 주기억장치에 저장된 데이터와 캐시들에 적재된 복사본이 서로 다른 값을 가지는 현상

3-6. 다중 캐시

1) 온-칩 캐시와 계층적 캐시

• 온-칩 캐시: CPU 칩 내부에 포함되어 있는 캐시
• 인출할 명령어나 데이터가 온-칩 캐시에 있다면 액세스 시간이 더 짧아져서 전체 시스템의 성능 향상에 도움이 됨

• 계층적 캐시: 여러 레벨의 캐시들을 계층적으로 설치한 구조
  • L2가 L1의 슈퍼-세트
• L1과 L2에서는 서로 다른 사상 알고리즘과 교체 알고리즘 및 쓰기 정책이 사용되는 경우가 많음
  • 따라서 이러한 계층적 캐시 시스템에서는 데이터 일관성 유지가 더 복잡해짐

2) 분리 캐시

• 최근에는 온-칩 캐시를 명령어만 저장하는 명령어 캐시와 데이터만 저장하는 데이터 캐시로 분리시켜 용도를 구분
• 명령어 실행 파이프라인에서 명령어 인출 단계와 오퍼랜드 인출 단계 간에 캐시에 대한 충돌 현상 제거 가능

CPU의 구조와 기능

• CPU는 기억장치에 저장되어 있는 프로그램 코드인 명령어들을 실행하며 '프로그램 수행'이라는 컴퓨터의 기본 기능을 수행
  1. 명령어 인출: 기억장치로부터 명령어를 읽어옴
  2. 명령어 해독: 수행해야 할 동작을 결정하기 위하여 명령어를 해독
  3. 데이터 인출: 명령어 실행을 위하여 데이터가 필요한 경우에는 기억장치 or I/O 장치로부터 그 데이터를 읽어옴
  4. 데이터 처리: 데이터에 대한 산술 or 논리 연산을 수행
  5. 데이터 저장: 수행한 결과를 저장
• 위 동작들 중 1, 2번 동작은 모든 명령어들에 대하여 공통적으로 수행되지만, 3-5번 동작은 명령어에 따라 필요한 경우에만 수행

1. CPU의 기본 구조

• CPU의 구성 요소
  • 산술논리연산잔치(ALU): 각종 산술 연산들과 논리 연산들을 수행하는 회로들로 이루어진 하드웨어 모듈
  • 레지스터 세트: CPU 내부에 위치한 기억장치로서, 액세스 속도가 컴퓨터의 기억장치들 중에서 가장 빠름. 그러나 내부 회로가 복잡하여 비교적 큰 공간을 차지하기 때문에, 많은 수의 레지스터들을 CPU의 내부에 포함시키기는 어려워 특수 목적용 레지스터들과 적은 수의 일반 목적용 레지스터들만 포함
  • 제어 유닛: 프로그램 코드를 해석하고, 그것을 실행하기 위한 제어 신호들을 순차적으로 발생하는 하드웨어 모듈
    • 명령어 실행에 필요한 각종 정보들의 전송 통로와 방향을 지정해주고, CPU 내부 요소들과 시스템 구성 요소들의 동작 시간도 결정
    • CPU가 제공하는 명령어들의 수가 많아질 수록 제어 유닛의 내부 회로는 더 복잡해짐
      • 복잡도를 줄이기 위해 제어 유닛의 동작을 SW로 처리해주는 방법이 마이크로프로그래밍
      • 그러나 이 방법을 이용하면 명령어 실행 시간이 길어짐
      • 따라서 최근에는 명령어의 수를 가능한 줄이고 명령어 형식을 단순화함으로써, HW만으로 명령어를 실행할 수 있도록 하는 RISC(Reduced Instruction Set Computer) 설계 개념도 많이 사용되고 있음
• CPU 내부 버스
  • ALU와 레지스터들 간의 데이터 이동을 위한 데이터 선들과 주소 선들, 그리고 제어 유닛으로부터 발생되는 제어 신호들을 전송하는 선들로 구성
  • 외부의 시스템 버스와 직접 연결되지 않으며, 반드시 버퍼 레지스터나 인터페이스 회로를 통하여 시스템 버스와 접속
    
    

2. 명령어 실행

• CPU가 한 개의 명령어를 실행하는 데 필요한 전체 과정이 명령어 사이클
  • 명령어 사이클은 CPU가 기억장치로부터 명령어를 읽어 오는 명령어 인출 단계와 (인출 사이클)
  • 인출된 명령어를 실행하는 명령어 실행 단계로 이루어짐 (실행 사이클)
• 명령어 사이클은 CPU가 프로그램 실행을 시작한 순간부터 전원을 끄거나 회복 불가능한 오류가 발생하여 중단될 때 까지 반복 수행
• 명령어 실행을 위해 기본적으로 필요한 CPU 내부 레지스터
  • 프로그램 카운터(PC): 다음에 인출될 명령어의 주소를 가지고 있는 레지스터
  • 누산기(AC): 데이터를 일시적으로 저장하는 레지스터. CPU가 한 번에 처리할 수 있는 데이터의 비트 수와 크기가 같음
  • 명령어 레지스터(IR): 가장 최근에 인출된 명령어가 저장되어 있는 레지스터
  • 기억장치 주소 레지스터(MAR): 프로그램 카운터에 저장된 명령어 주소가 시스템 주소 버스로 출력되기 전에 일시적으로 저장되는 주소 레지스터
  • 기억장치 버퍼 레지스터(MBR): 기억장치에 저장될 데이터 혹은 이미 읽어온 데이터가 일시적으로 저장되는 버퍼 레지스터

2-1. 인출 사이클

• CPU는 각 명령어 사이클의 시작 단계에서 PC가 가리키는 기억장치의 위치로부터 명령어를 인출
• 그런 다음 CPU는 PC의 내용을 1씩 증가시킴으로써 명령어들을 기억장치에 저장되어 있는 순서대로 읽어올 수 있도록 해줌
• 인출 사이클에서 수행되는 동작의 마이크로 연산(CPU 클록의 각 주기 동안 수행되는 기본적 동작)
  • t0: MAR <- PC // 현재 PC 내용을 CPU 내부 버스를 통하여 MAR로 보냄
  • t1: MBR <- M[MAR], PC <- PC + 1 // 그 주소가 지정하는 기억장치 위치로부터 읽혀진 명령어가 데이터 버스를 통하여 MBR로 적재 + PC 증가
  • t2: IR <- MBR // MBR에 저장되어 있는 명령어 코드가 명령어 레지스터인 IR로 이동
  • cf. t0, t1, t2는 CPU 클록의 각 주기를 가리킴
• 명령어 인출에는 세 개의 CPU 클록 주기만큼의 시간이 걸림
  • CPU의 클록 주파수가 1GHz라면 클록 주기가 1ns이므로, 인출 사이클은 3ns

2-2. 실행 사이클

• 인출된 명령어를 CPU가 해독하고, 그 결과에 따라 필요한 연산 수행
• CPU 수행 연산
  1. 데이터 이동: CPU와 기억장치 간 혹은 CPU와 I/O 장치 간 데이터 이동
     • ex) LOAD addr
     • t0: MAR <- IR(addr)
     • t1: MBR <- M[MAR]
     • t2: AC <- MBR
  2. 데이터 처리: 데이터에 대하여 산술 or 논리 연산 수행
     • ex) ADD addr
     • t0: MAR <- IR(addr)
     • t1: MBR <- M[MAR]
     • t2: AC <- AC + MBR
  3. 데이터 저장: 연산결과 데이터 혹은 입력장치로부터 읽어들인 데이터 기억장치에 저장
     • ex) STA addr
     • t0: MAR <- IR(addr)
     • t1: MBR <- AC
     • t2: M[MAR] <- MBR
  4. 프로그램 제어: 프로그램의 실행 순서 결정
     • ex) JUMP addr
     • t0: PC <- IR(addr)

2-3. 인터럽트 사이클

• CPU로 하여금 현재 진행 중인 프로그램 처리를 중단하고 다른 프로그램을 처리하도록 요구하는 메커니즘으로서, CPU와 외부장치들 간의 상호작용을 위하여 필요한 기능
• 인터럽트 서비스 루틴(ISR): 인터럽트 요구를 처리해주기 위해 수행하는 프로그램 루틴
• 인터럽트 사이클: 인터럽트 요구가 들어왔는지 검사하고, 그 처리에 필요한 동작들을 수행하는 과정
  1. 인터럽트 요구 신호 검사
  2. t0: MBR <- PC // 현재 PC 내용을 스택에 저장(인터럽트 처리 완료 후, 복귀 위함)
  3. t1: MAR <- SP, PC <- ISR의 시작 주소 // PC에 해당 ISP의 시작 주소를 적재
  4. t2: M[MAR] <- MBR, SP <- SP - 1 // 원래 PC의 내용을 스택에 저장 후, SP 감소
• 프로그램에 따라 **인터럽트 가능 상태(EI)**와 **인터럽트 불가능 상태(DI)**가 있음
• 인터럽트 사이클로 인해 AC에 저장된 값이 바뀔 수 있기 때문에, 인터럽트 서비스 루틴의 시작 단계에서 레지스터들의 내용을 스택에 저장하였다가, 루틴의 마지막 단계에서 복원시켜주는 절차가 필요함
• 다중 인터럽트의 처리 방법
  • 1. CPU가 ISR을 처리하고 있는 도중에는 새로운 인터럽트 요구가 들어오더라도 인터럽트 사이클을 수행하지 않도록 하는 것
    • 이전 루틴을 처리하는 동안 CPU는 DI 상태. 루틴 처리하는 동안 발생한 인터럽트 요구는 대기 상태로 남아 있다가, CPU가 EI 상태로 바뀐 후에 인식됨
  • 2. 인터럽트 요구들 간에 우선순위를 정하고, 우선순위에 따라 수행 여부 판단
    • 스택에는 원래의 주프로그램으로 복귀하기 위한 주소뿐 아니라, 첫 번째 ISR으로 복귀하는데 사용될 주소도 저장되어야 함

2-4. 간접 사이클

• 실행 사이클에서 사용될 데이터의 실제 주소를 기억장치로부터 읽어오는 과정
  • t0: MAR <- IR(addr)
  • t1: MBR <- M[MAR]
  • t2: IR(addr) <- MBR
• 간접 사이클은 항상 수행되는 것이 아니며, 명령어 내의 특정 비트(ex: I 비트)가 1로 세트된 경우에만 수행
  
  

3. 명령어 파이프라이닝

• 명령어를 실행하는데 사용되는 하드웨어를 독립적인 단계로 분할하고, 그들로 하여금 동시에 서로 다른 명령어들을 처리하도록 함으로써 CPU의 성능을 높여주는 기술
• 분할되는 단계의 수가 많아질수록 처리 속도가 높아짐

3-1. 2단계 명령어 파이프라인

• 명령어를 실행하는 하드웨어를 인출 단계와 실행 단계라는 두 개의 파이프라인 단계로 분리 구성
• 명령어 선인출: 다음에 실핼될 명령어를 미리 인출하는 동작
• 많은 수의 명령어들을 실행시키는 경우에 얻을 수 있는 최대 속도 향상은 파이프라인 단계의 수와 같은 2배에 접근하게 됨
• 그러나, 실제로는 실행 단계가 인출 단계보다 더 긴 수행 시간을 보이기 때문에 2배만큼 빨리지지는 못함

3-2. 4단계 명령어 파이프라인

• 파이프라인 단계들의 처리 시간이 동일하지 않음으로 인하여 발생하는 효율 저하를 방지하는 방법
• 파이프라인을 명령어 인출(IF) - 명령어 해독(ID) - 오퍼랜드 인출(OF) - 실행(EX)의 4단계로 구성
• 파이프라이닝을 이용하여 얻을 수 있는 속도 향상의 관계식
  • T = k + (N - 1)
  • 파이프라인 단계의 수 k, 실행할 명령어들의 수 N
  • 첫 번째 명령어를 실행하는 데 k 주기가 걸리고, 나머지 (N-1)개의 명령어들은 각각 한 주기씩만 소요
  • 파이프라이닝을 사용하지 않을 경우, k x N 주기를 소모
• k-단계 파이프라이닝의 문제
  • 1. 모든 명령어가 k 단계를 거치지는 않음
    • 어떤 명령어는 실행 과정에서 오퍼랜드의 인출이 필요 없을 수도
  • 2. 파이프라인 클록은 처리 시간이 가장 오래 걸리는 단계를 기준으로 정해짐 -> 쓸데없는 대기 시간 있을 수 있음
  • 3. 기억장치 충돌의 문제가 있을 수 있음
    • IF 단계와 OF 단계는 모두 기억장치를 액세스하는데 이 때 기억장치 충돌의 문제 발생
  • 4. 조건 분기 명령어가 실행된다면, 미리 인출되어 파이프라인에서 처리하고 있던 명령어들이 무효화될 수 있음
• 슈퍼파이프라이닝: 2번 문제의 해결을 위해 명령어 파이프라인의 단계들을 더욱 잘게 분할하여 처리 속도를 높여주는 기술
  • 최근에는 대부분의 프로세스들이 10 단계 이상의 단계들로 분할된 명령어 파이프라인 구조를 사용
• 3번 문제의 보완을 위해 IF 단계와 OF 단계가 직접 액세스하는 CPU 내부 캐시를 명령어 캐시와 데이터 캐시로 분리시키는 방법이 사용됨
• 조건 문기로 인한 성능 저하를 최소화시키기 위한 해결책
  • 분기 예측: 분기가 일어날 것인지를 예측하고, 그에 따라 어느 경로의 명령어를 인출할 지를 결정하는 확률적 방법. 최근 분기 결과들을 저장하여 두는 분기 역사 표를 참조하여 예측하는 방법이 가장 널리 사용
  • 분기 목적지 선인출: 조건 분기가 인식되면, 분기 명령어의 다음 명령어뿐 아니라, 조건이 만족될 경우에 분기하게 될 목적지의 명령어도 함께 인출하는 방법. 이 방법의 사용을 위해서는 분기 목적지 명령어를 별도로 저장해둘 수 있는 기억 장소가 추가되어야 함
  • 루프 버퍼: 파이프라인의 명령어 인출 단계에 포함되어 있는 작은 고속 기억장치로 가장 최근에 인출된 일정 개수의 명령어들이 순서대로 저장됨
  • 지연 분기: 분기 명령어의 위치를 적절히 조정하여 원래보다 나중에 실행되도록 재배치함으로써, 성능 저하를 최소화하는 방법
• 조건 분기 명령어에서 사용하는 조건들은 CPU 내부의 상태 레지스터에 저장
  • 상태 레지스터: 연산처리 결과 및 시스템 상태를 가리키는 비트들을 저장하는 레지스터

3-3. 슈퍼스칼라

• CPU 내에 여러 개의 명령어 파이프라인들을 두어, 동시에 그 수만큼의 명령어들을 실행할 수 있도록 한 구조
• 슈퍼스칼라 프로세서에서 유의할 점으로는 동시에 처리할 명령어들이 서로 간에 영향을 받지 않고 독립적으로 실행될 수 있어야 한다는 것
  • 두 명령어 사이에 데이터 의존성이 존재하지 않아야 함!
  • 명령어들 간 데이터 의존성이 존재하면 파이프라인들의 일부 단계들이 idle 상태에 들어가 속도 향상을 저해
• m-way 슈퍼스칼라 프로세서가 N개의 명령어들을 실행하는 데 걸리는 전체 시간
  • T(m) = k + N-m/m
  • 처음 m개의 명령어들을 실행하는 k 주기 소요 + 매 주기마다 m개씩의 명령어들이 동시에 실행 완료

3-4. 듀얼 코어 및 멀티 코어

• 멀티 코어 프로세서: CPU 코어 여러 개를 하나의 칩에 넣은 것
• 멀티 코어에서는 각 CPU 코어가 슈퍼스칼라의 명령어 파이프라인에 비하여 독립성이 더 높음
  • 별도의 하드웨어 모듈로, 시스템 버스 인터페이스와 내부 캐시만 공유
  • 따라서 각 CPU 코어는 프로그램 실행을 독립적으로 수행하며, 필요한 경우에만 공유 캐시를 통해 정보 교환
• 독립적인 처리가 가능한 단위로 분할된 태스크 프로그램들이 CPU 코어들에 의해 동시에 처리됨
  • 이와 같은 동시처리 기술을 멀티 태스킹 혹은 멀티 스레딩이라 부름
  • CPU 코어가 많을수록 그 수만큼의 태스크 프로그램들을 동시에 처리할 수 있게 됨

시스템 버스, I/O 및 인터럽트

1. 시스템 버스

1-1. 시스템 버스의 조직

• 시스템 버스에 접속되는 모든 요소들은 버스를 통하여 상호간에 정보를 교환하고, 동작 시간을 조정하기 위한 클록 신호 전송
• 시스템 버스를 구성하는 선들의 수는 한 번에 전송하는 데이터 비트들의 수가 기억장치 비트들의 수 및 제어 신호들의 수에 따라 결정
• 데이터 버스: 시스템 요소들 사이에 데이터를 전송하는 데 사용되는 선들의 집합
  • CPU가 8비트씩 읽어오면 8개의 선, 32비트씩 읽어오면 32개의 선이 필요
  • 데이터는 CPU-기억장치, CPU-I/O장치 및 기억장치-I/O 장치 사이에 양방향으로 전송되기 때문에, 데이터 버스는 양방향 전송을 지원해야 함
• 주소 버스: CPU가 기억장치나 I/O 장치에 액세스할 때 주소 비트들을 전송하는 데 사용되는 선들의 집합
  • 주소는 CPU에 의해서만 발생되기 때문에 단방향 전송 기능만 있으면 됨
  • 주소 버스의 폭은 CPU가 주소 지정할 수 있는 전체 기억장치 용량을 결정
• 제어 버스: 제어 신호들을 전송하기 위한 선들의 집합
  • ex) 기억장치 쓰기/읽기 신호, I/O 쓰기/읽기 신호
• 버스 마스터: 시스템 버스 사용의 주체가 되는 요소
  • 일반적인 컴퓨터 시스템에서는 CPU와 I/O 제어기 등이 버스 마스터
  • 동기식 버스 시스템에서는 기억장치 모듈도 버스 마스터가 될 수 있음
• 두개 이상의 마스터들이 동시에 버스를 사용하고자 할 때는 순서대로 사용하도록 버스 중재를 해주어야 함
• 중재 버스의 종류
  • 버스 요구 신호: 버스 마스터가 버스 사용을 원하고 있음
  • 버스 승인 신호: 버스 사용을 요구한 마스터에게 사용을 허가
  • 버스 사용 중 신호: 현재 어떤 마스터가 버스를 사용하고 있는 중
• CPU와 I/O 장치 간의 비동기적 동작을 지원하는 인터럽트 메커니즘을 위한 제어 신호
  • 인터럽트 요구 신호
  • 인터럽트 확인 신호
• 버스 대역폭: 버스를 통하여 단위시간 당 전송할 수 있는 데이터량으로서, 단위는 초당 바이트 수로 나타냄

1-2. 시스템 버스의 기본 동작

• 버스 상의 모든 동작들은 쓰기 동작과 읽기 동작으로 구분
• 동기식 버스: 모든 버스 동작들이 발생하는 시간이 공통의 버스 클록을 기준으로 결정되는 버스
  • 인터페이스 회로가 간단하는 장점
  • 버스 클록의 주기가 가장 오래 걸리는 버스 동작의 소요 시간을 기준으로 정해져야 하기 때문에, 클록 주기보다 짧은 시간이 걸리는 버스 동작의 경우 동작이 완료된 후에도 기다려야 한다는 단점
• 비동기식 버스: 버스 동작들의 발생 시간이 다른 버스 동작의 발생 여부에 따라 결정되는 버스
  • 동기식 버스에서와 같이 낭비되는 시간이 없다는 장점
  • 연속적 동작들을 처리하기 위한 인터페이스 회로가 복잡해지는 단점
    
    

2. 버스 중재

• 버스 경합이 발생한 경우 버스 마스터들 중에서 한 개씩 선택하여 순서대로 버스를 사용할 수 있게 해주는 행위
• 버스는 Fair하게 배분되어야 하며, 배분으로 인한 Starvation 현상이 없어야 함

2-1. 병렬 중재 방식

각 버스 마스터가 독립적인 버스요구 신호를 버스 중재기로 보내며, 별도의 버스 승인 신호를 받는 방식

1) 중앙집중식 고정-우선순위 방식

• 각 버스 마스터에 지정된 우선순위가 변하지 않는 고정-우선순위 방식과 우선순위가 계속 변하는 가변-우선순위 방식이 존재
• 각 버스 마스터는 자신의 버스 요구(BREQ)선을 가지며, 이들은 모두 하나의 버스 중재기로 접속
• 버스 중재기는 한 개 이상의 버스 요구 신호를 받아서, 그 중 우선순위가 가장 높은 마스터의 버스 승인(BGNT) 신호 셋
• BBUSY 신호는 어떤 버스 마스터가 버슬르 사용하고 있는 중이라는 것을 의미
• 각 마스터에 대한 BGNT 신호는 더 높은 우선순위를 가진 마스터가 버스 요구를 발생하지 않은 상태에서 BREQ를 1로 세트했을 때만 활성화 가능

2) 분산식 고정-우선순위 방식

• 모든 버스 마스터들이 중재기를 한 개씩 가지고 있음
• 자신보다 더 높은 우선순위를 가진 버스 마스터들의 버스 요구 신호들을 입력으로 받아 검사하고, 그들 중 어느 것도 버스 사용 요구를 하지 않은 경우에만 자신의 버스 승인 신호를 셋
• 분산식 중재 방식은 중앙집중식에 비하여 중재 회로가 간단하기 때문에 동작 속도가 더 빠르다는 장점
• 그러나, 고장을 일으킨 중재기를 찾아내기가 힘들며, 한 중재기의 고장이 전체 시스템에 동작에 영향을 줄 수도 있다는 단점 존재

3) 가변 우선순위 방식

• 버스 중재기가 시스템의 상태 또는 조건에 따라 각 버스 마스터들의 우선순위를 계속 바꾸어 줌
• 중재 회로는 더 복잡해지지만, 버스 마스터들이 버스를 균등하게 사용할 수 있게 됨
• 최상위 우선순위를 가진 마스터가 버스를 독점하거나, 최하위 우선순위를 가진 마스터가 오랫동안 버스를 사용하지 못하는 기근 현상의 방지를 위한 방식
• 가변 우선순위 알고리즘
  • 회전 우선순위
    • 1. 중재 동작이 끝날 때마다 모든 마스터들의 우선순위가 낮아지고, 가장 우선순위가 낮았던 마스터가 최상위 우선순위를 가지는 방법
    • 2. 버스 사용 승인을 받은 마스터는 최하위 우선순위를 가지며, 바로 다음에 위치한 마스터가 최상위 우선순위를 가지도록 하는 방법
  • 임의 우선순위: 각 중재 동작이 끝날 때마다 마스터들의 우선순위가 난수 발생기에 의해 임의로 정해지는 방식
  • 동등 우선순위: 모든 마스터들이 동등한 우선순위를 가지는 방식
  • 최소-최근 사용: 최근 가장 오랫동안 버스를 사용하지 않은 버스 마스터에게 최상위 우선순위를 할당하는 방식
    
    

2-2. 직렬 중재 방식

버스요구 신호와 버스승인 신호가 하나씩 있으며, 각 신호 선이 모든 버스 마스터들 간에 직렬로 접속되는 방식

1) 중앙집중식 직렬 중재 방식

• 하나의 중재 신호선에 의해 모든 버스 마스터들이 직렬로 연결되어 데이지 체인형태를 이룸
• 마스터들의 우선순위는 버스 중재기를 시작점으로 하여 승인 신호 선이 연결된 순서대로 정해짐(중재기에 가까운 것이 높은 우선순위)
• 어떤 마스터도 버스를 사용하지 않을 때만 버스 중재기가 승인 신호를 발생하도록 설계해야 함
  1. BBUSY 신호가 해제될 때 까지는 버스 마스터들이 요구 신호를 보낼 수 없거나,
  2. 버스 요구 신호는 항상 발생시킬 수 있지만, 승인 신호를 받은 후에도 BBUSY 신호가 해제될 때까지는 버스를 사용할 수 없도록 함

2) 분산식 직렬 중재 방식

• 데이지-체인 버스 승인 신호(DBGNT) 선이 버스 중재기들을 순환형으로 접속한 형태로 구성
• 버스 사용권을 부여받은 마스터가 버스 사용을 시작하는 순간에 DBGNT 신호를 세트하여 자신의 바로 우측 마스터의 중재기로 보내줌
• 신호를 받은 중재기의 마스터가 버스 사용을 신청한 상태였으면 BGNT 신호를 발생시켜 마스터에게 보내며, 버스 요구를 하지 않은 상태라면 다음 중재기로 넘겨줌
• 각 마스터의 우선순위가 계속 변한다는 특징
  • 즉, 어떤 마스터가 버스 사용 승인을 받으면 그 마스터는 다음 중재 동작에서는 최하위 우선순위를 가지게 되고, 그 마스터의 바로 우측에 위치한 마스터가 최상위 우선순위를 가지게 됨
• 이 방식은 분산식이지만, 어떤 한 중재기에 결함이 발생하면 DBGNT 신호를 통과시킬 수 없기에 전체 동작이 중단될 수 있음
  
  

2-3. 폴링 방식

버스 중재기가 각 마스터들이 버스 사용을 원하는지를 주기적으로 검사하여 버스 승인 여부를 결정

1) 하드웨어 폴링 방식

• 중재기 내의 고정된 하드웨어를 이용한 주기적 검사를 통해 중재 기능을 수행하는 방식
• N개의 마스터를 가진 시스템에는 N개의 폴링 선 혹은 2진 코드화된 폴링 주소를 사용할 시 logN개의 폴링 선 필요
• 각 마스터들의 우선순위는 중재기가 마스터를 검사하는 순서에 의해 결정됨

2) 소프트웨어 폴링 방식

• 하드웨어 폴링 방식과 동일하게 구성
• 그러나 중재 동작이 고정된 하드웨어에 의해 이루어지는 것이 아니라 프로세서의 의해 조정되는 방식
  • 하드웨어 방식에 비하여 속도가 더 느리지만, 융통성이 높다는 장점
• 중재 프로세서는 다음에 폴링할 마스터의 주소를 기억할 수 있고, 필요에 따라 폴링 순서를 변경할 수도 있음
• 만약 어떤 버스 마스터에 결함이 발생한다면, 그 마스터를 폴링 순서에서 제외하여 시스템 결함 허용도를 높일 수 있음
  
  

3. 인터럽트를 이용한 I/O

프로그램을 이용한 I/O 방식은 CPU가 I/O 동작에 계속 관여해야 하기 때문에 CPU 시간의 낭비를 초래

• 인터럽트 메커니즘을 이용하여 CPU와 I/O 장치간 상호작용을 처리하는 인터럽트-구동 I/O 방식을 통해 해결 가능
  1. CPU가 I/O 제어기에 명령을 보냄. 그 후, CPU는 다른 작업 수행
  2. 제어기는 I/O 명령을 이용하여 I/O 장치를 제어
  3. I/O 장치가 명령 수행을 완료하면, 제어기는 CPU로 인터럽트 신호를 보냄
  4. CPU는 인터럽트 신호를 받는 즉시 원래의 프로그램으로 돌아와서 다음 작업을 계속함

3-1. 다중 인터럽트 방식

• 각 I/O 제어기와 CPU 상에 별도의 인터럽트 요구 신호선과 인터럽트 확인 신호선이 한 개씩 존재
• 두 개 이상의 I/O 장치들이 동시에 인터럽트 요구 신호를 보내는 경우, 각 I/O 장치에 대하여 우선순위를 정하고, 더 높은 우선순위를 가진 장치의 인터럽트 요구부터 확인 신호를 보내고 서비스
• 각 I/O 장치가 별도의 인터럽트 선을 가지고 있기 때문에 CPU가 인터럽트를 요구한 장치를 쉽게 찾아낼 수 있다는 장점

3-2. 데이지-체인 방식

• 모든 I/O 제어기들은 한 개의 인터럽트 요구 신호 선을 공유
• 인터럽트 확인 신호는 첫 번째 I/O 제어기로 보내짐
  • 만약 그 제어기가 인터럽트를 요구한 상태라면, 즉시 데이터 버스를 통해 자신의 ID(인터럽트 벡터)를 CPU에 보냄
  • 인터럽트를 요구한 상태가 아니라면, 그 제어기는 확인 신호를 다음 제어기로 통과시킴
• 간단한 하드웨어 구성이지만, 많은 수의 I/O 장치들이 접속된 시스템에서는 기근 현상 초래할 가능성 있음

3-3. 소프트웨어 폴링 방식

• 한 개의 TEST I/O 선이 CPU와 모든 제어기들 사이에 연결
• TEST I/O 신호는 각 제어지 내 인터럽트 플래그의 상태를 확인
• 데이지-체인 방식과 같은 방식으로 작동하지만 소프트웨어가 그 역할을 수행하는 것이 차이
  
  

4. DMA를 이용한 I/O

인터럽트-구동 I/O 방식 역시 기억장치와 I/O 장치간 데이터 이동에 CPU가 직접 개입해야 하며, 이동되는 데이터들이 반드시 CPU를 경유해야 하는 문제 존재

• DMA(Direct Memory Access)란 CPU의 개입 없이 I/O 장치와 기억장치 사이에 데이터 전송을 수행하는 메커니즘
• CPU는 DMA 제어기로 다음과 같은 정보들이 포함된 명령어를 보냄
  • I/O 장치의 주소
  • 연산 지정자
  • 데이터가 읽혀지거나 쓰여질 주기억장치 영역의 시작 주소
  • 전송될 데이터 단어들의 개수
• CPU는 I/O 동작을 DMA 제어기에게 맡기고, 모든 데이터 전송 동작이 완료될 때까지 전혀 개입하지 않음
• CPU와 DMA는 시스템 버스를 공유: DMA가 시스템 버스를 통해 주기억장치에 접근하기 때문
• DMA 제어기는 가능한 한 CPU의 정상적 동작을 방해하지 않으며 시스템 버스를 사용
• 이로 인해 DMA를 사이클 스틸링이라고도 부름
• 그러나 큰 데이터 블록 전송의 경우 스틸한 사이클만 사용하기에는 턱없이 부족
• 일반적으로 DMA 제어기가 시스템 버스 사용(BUS REQ)을 요구하면, CPU는 현재 사이클이 끝나는 즉시 사용 허가(BUS GRANT)를 해줌

• DMA 제어기의 내부 구조
  • I/O 장치의 주소를 저장하는 '주소 레지스터'
  • 데이터 버퍼 역할을 하는 '데이터 레지스터'
  • 전솔될 데이터 수를 저장하는 '카운터 레지스터'
  • 각종 제어 신호들을 발생하거나 받아들이기 위한 '제어 회로'
• 시스템 버스에 주기억장치, I/O 제어기가 모두 달려있는 경우, 데이터 x 2번만큼 시스템 버스를 사용 -> 비효율
• DMA 제어기 아래에 I/O 제어기를 두자 !
  • 시스템 버스는 데이터 x 1번 만큼만 사용하면 됨
  • 그러나, 각 DMA 제어기에 직접 접속할 수 있는 I/O 제어기의 수가 제한되어 여러 DMA 제어기들을 두어야 할 수도 있음
• DMA 제어기를 시스템 버스와 I/O 버스 사이에 위치시키고, I/O버스를 통해 I/O 장치를 제어하자!
• I/O 장치들은 종류와 속도가 다양하고 제어 방법도 복잡하기 때문에, 간단한 구조를 가진 DMA제어기로 지원하는 데 한계 존재
• 디스크 쓰기/읽기의 경우 데이터 블록의 크기가 512byte 이상이기 때문에 그 데이터들을 임시 저장하기 위한 내부 기억 장치 필요

• I/O 장치들의 동작을 제어하며 DMA 동작도 제어하는 프로세서인 I/O 프로세서(IOP)의 사용

  • I/O 제어 프로그램을 수행할 수 있는 프로세서
  • 데이터 블록을 임시 저장할 수 있는 용량의 지역 기억장치
  • 시스템 버스 인터페이스 및 버스 마스터 회로
  • I/O 버스 인터페이스 및 중재 회로로 구성