개발 창고

HTTP와 HTTPS의 차이점

Eunbae — Thu, 1 Sep 2022 23:41:52 +0900

HTTP는 무엇일까?

HTTP는 Hyper Text Transfer Protocol의 약자로, 인터넷 상에서 데이터(Hyper Text)를 주고 받기 위해서(Transfer) 서버/클라이언트 모델을 따르는 프로토콜입니다. 주로 웹 브라우저와 웹 서버간의 커뮤니케이션을 위해서 디자인 되었으며 ??

HTTP는 주로 TCP를 사용하고, 2020년부터 도입된 HTTP/3에서는 UDP를 사용합니다. 또한 기본 포트로 80번을 사용한다는 특징이 있습니다.

서버/클라이언트 모델: 클라이언트가 요청을 생성하기 위한 연결을 연다음 응답을 받을때 까지 대기하는 전통적인 방식

프로토콜: 컴퓨터 내부 또는 컴퓨터 사이에서 데이터의 교환 방식을 정의하는 규칙 체계

HTTP의 문제점

HTTP 서버는 기본 80번 포트에서 서비스를 대기하고 있으며, 만약 웹 브라우저가 80번 포트를 연결하여 데이터를 요청하면 서버는 요청에 해당하는 데이터(Hyper Text)를 전송하면서 응답하게 됩니다.

이 과정에서 누군가가 네트워크 신호를 가로채는 경우, 데이터는 외부에 그대로 노출되어 데이터가 도난당할 수 있다는 문제점이 존재합니다. 이러한 보안 취약점을 해결하기 위해 HTTPS가 등장하였습니다.

HTTPS!

HTTPS는 HTTP에서 Secure socket layer, 즉 데이터 전송 과정에서 보안이 추가된 프로토콜입니다. 데이터 전송시 텍스트를 사용하는 대신, SSL이나 TLS 프로토콜을 통해 세션 데이터를 암호화하기 때문에 데이터의 보호를 보장합니다. 그리고 HTTP와는 다르게 기본 포트로 443번을 사용한다는 특징이 있습니다.

따라서 HTTPS를 사용하면 클라이언트가 금융 활동 이나 온라인 쇼핑을 할 때 민감한 개인 정보를 서버와 안전하게 주고 받을 수 있게 됩니다.

SSL? TLS? : SSL(Secure Sockets Layer), TSL(Transport Layer Security)는 네트워크에 통신 보안을 제공하기 위해 설계된 암호 규약입니다. 이때 TLS는 SSL이 표준화되면서 바뀐 이름입니다. 따라서 TLS안에 SSL이 있다 할 수 있습니다.

그렇다면 HTTPS에서 보안이 어떤 방식으로 동작할까?

브라우저에서 https를 사용하는 사이트일 경우 보안 연결이 사용되었다는 문구를 볼 수 있습니다.

HTTPS는 SSL 암호화 통신, 즉 공개키 암호화 방식의 알고리즘을 통해 보안을 구현합니다. 그렇다면 공개키 암호화 방식에 대해서 알아보겠습니다.

공캐키 암호화 방식

공개키 암호화 방식은 암호 방식의 한 종류로 암호화와 복호화에 이용하는 키가 다른 방식을 말합니다. 공개키와 암호키가 존재하며, 위 그림에서 Hello Alice!라는 문구를 공개키로 암호화했다면 오직 암호키로만 이를 복호화할 수 있습니다. 반대로 암호키로 암호화했다면 공개키로만 복호화 할 수 있습니다.

이 방식을 이용한 클라이언트와 서버간의 흐름을 간단하게 정리해보았습니다.

클라이언트는 공개키로 HTTP요청을 암호화합니다.
이 요청을 받은 서버는 암호키로 요청을 복호화해서 해독합니다.
서버는 요청에 해당하는 데이터를 암호키로 암호화하여 클라이언트에 응답합니다.
클라이언트는 응답을 공개키로 응답을 복호화하여 해독합니다.

보안 말고 또 다른 차이점?

구글 등의 검색 엔진에서는 HTTPS를 사용한 사이트에 SEO(Search Engine Optimization) 가산점을 부여합니다. 따라서 동일한 키워드를 검색하더라도 HTTPS가 적용된 안전한 사이트가 더 상위에 노출됩니다.

요약

HTTPS는 인터넷 상에서 데이터를 주고받기위한 프로토콜인 HTTP에 보안이 추가된 방식입니다. 보안은 공개키 암호화 방식을 사용하는 SSL 암호화 통신을 통해 구현됩니다. 따라서 둘의 차이점은 보안의 적용유무에 있다고 할 수 있습니다.

참고문서

https://developer.mozilla.org/ko/docs/Web/HTTP

https://ko.wikipedia.org/wiki/HTTP

https://ko.wikipedia.org/wiki/HTTPS

https://post.naver.com/viewer/postView.nhn?volumeNo=16561296&memberNo=1834

https://ko.wikipedia.org/wiki/%EA%B3%B5%EA%B0%9C_%ED%82%A4_%EC%95%94%ED%98%B8_%EB%B0%A9%EC%8B%9D

JS 자료구조&알고리즘 (4) - 검색과 정렬

Eunbae — Wed, 13 Jul 2022 16:40:40 +0900

10장. 검색과 정렬

검색 (search)

- 검색은 자료 구조 내에 특정 항목을 찾는 일을 말하며, 배열이 정렬됐는지 여부에따라 두 가지 주요 기법이 있다.

선형 검색

배열의 각 항목을 한 인덱스씩 순차적으로 접근하면서 동작한다.
시간 복잡도 : O(n)
배열의 정렬 여부와는 관계없이 동작하기때문에 좋으므로 정렬되지 않은 배열을 검색하기 좋다.

function linearSearch(arr, n) {
    for(var i = 0; i < arr.length; i++){
        if (arr[i] == n) return true;
    }
    return false;
}

이진 검색 (탐색)

중간 값을 확인해서 원하는 값보다 중간 값이 작은지 큰지를 확인하면서 동작한다.
시간 복잡도: O(logn)
이진 탐색은 빠르지만 배열이 정렬된 경우에만 사용할 수 있다.

function binarySearch(arr, n) {
    var lowIdx = 0, highIdx = arr.length - 1;

    while (lowIdx <= highIdx) {
        var midIdx = Math.floor((highIdx + lowIdx) / 2);
        if (arr[midIdx] == n) return arr[midIdx];
        else if (n>arr[midIdx]) lowIdx = midIdx;
        else highIdx = midIdx;
    }
    return -1;
}

정렬 (sort)

거품 정렬 (bubble sort)

가장 간단한 알고리즘으로, 전체 배열을 순회하면서 항목이 다른 항목보다 큰 경우 두 항목을 교환한다.
시간 복잡도: O(n^2) (중첩 루프)
거품 정렬은 모든 가능한 짝을 비교하기 때문에 최악의 정렬이라 할 수 있다.

function bubbleSort(array) {
  for (var i = 0, arrayLength = array.length; i < arrayLength; i++) {
    for (var j = 0; j <= i; j++) {
      if (array[i] < array[j]) {
        swap(array, i, j);
      }
    }
  }
  return array;
}

책의 예시는 인접 두 항목을 교환하는 코드가 아니어서 제로초님의 블로그글을 참고하여 공부하였다.

function bubbleSort(array) {
  for (var i = 0, arrayLength = array.length; i < arrayLength - 1; i++) {
    for (var j = 0; j < arrayLength - 1 - i; j++) {
      if (array[j] > array[j+1]) { // 인접항목 교환
        swap(array, j, j+1);
      }
    }
  }
  return array;
}

선택 정렬 (selection sort)

가장 작은 항목을 찾아서 해당 항목을 배열의 현 위치에 삽입한다.
시간 복잡도 : O(n^2) (중첩 루프)

function selectionSort(items) {
  var len = items.length, min;

  for (var i = 0; i < len; i++) {
    min = i;
    for (j = i+1; j < len; j++) { 
      if (items[j] < items[min]) {
        min = j; // 최솟값의 위치를 min값에 할당
      }
    }
    if (i != min) { // 현재 위치가 최솟값의 위치가 아니면 교환
      swap(items, i, min);
    }
  }
  return items;
}

삽입 정렬 (insertion sort)

배열을 순차적으로 검색하면서 정렬되지 않은 항목들을 배열의 왼쪽의 정렬된 부분으로 이동시킨다.
시간 복잡도 : O(n^2) (중첩 루프)

function insertionSort(items) {
  var len = items.length, value, i, j;
  
  for (i=0; i < len; i++) {
    value = items[i]; // 현재 값 덮어써질수 있으므로 저장함

    for (j = i-1; j > -1 && items[j] > value; j--) { // value가 검사값보다 작다면 검사값 위치 +1
      items[j+1] = items[j];
    } // j는 검사값이 크지 않을 때 까지 감소한다.
    items[j+1] = value; // 감소한 j값 +1이 value의 위치(가장 작은값)
    console.log(items);
  }
  return items;
}

빠른 정렬 (quick sort)

기준점을 획득한 다음 해당 기준점을 기준으로 왼쪽은 작은 항목, 오른쪽은 큰 항목으로 배열을 나눈다.
시간복잡도: 평균 - O(nlog_2(n)), 최악 - O(n^2)
기준점을 항상 잘못 선택하는 경우는 시간 복잡도가 O(n^2)이 될 수 있다.

function quickSort(items) {
  return quickSortHelper(items, 0, items.length - 1);
}
function quickSortHelper(items, left, right) {
  var index;
  if (items.length > 1) {
    index = partition(items, left, right);

    if (left < index - 1) { // 기준점 왼쪽 빠른정렬
      quickSortHelper(items, left, index - 1);
    }
    if (index < right) { // 기준점 오른쪽 빠른정렬
      quickSortHelper(items, index, right);
    }
  }
  return items;
}
function partition(array, left, right) { // 기준점 중앙으로
  var pivot = array[Math.floor((right + left) / 2)];
  while (left <= right) {
    while (pivot > array[left]) {
      left++;
    }
    while (pivot < array[right]) {
      right--;
    }
    if (left <= right) {
      var temp = array[left];
      array[left] = array[right];
      array[right] = temp;
      left++;
      right--;
    }
  }
  return left;
}

빠른 선택 (quick select)

정렬되지 않은 목록에서 k번째로 작은 항목을 찾는 선택 알고리즘이다.
빠른 정렬과 같은 접근법을 사용하지만, 기준점의 양쪽 모두를 재귀적으로 수행하는 대신 한쪽만을 재귀적으로 수행한다는 차이점이있다.
이로인해 복잡도는 O(nlog_2(n))에서 O(n)으로 낮아진다.
시간복잡도: O(n)

function quickSelectInPlace(A, l, h, k) {
  var p = partition(A, l, h);
  if (p == (k-1)) {
    return A[p]; // 일치하면 값 return
  } else if (p > (k-1)) {
    return quickSelectInPlace(A, l, p-1, k); // pivot 왼쪽배열 재귀
  } else {
    return quickSelectInPlace(A, p+1, h, k); // pivot 오른쪽배열 재귀
  }
}

병합 정렬 (merge sort)

각 하위 배열에 하나의 항목이 존재할 때까지 배열을 하위 배열로 나눈 다음, 각 하위 배열을 정렬된 순서로 병합한다.
시간복잡도: O(nlog_2(n)), 공간복잡도: O(n)
병합 정렬은 O(n)의 공간을 사용한다는 단점이 있다.
왼쪽, 오른쪽의 두 배열을 가지고 하나의 결과 배열로 병합한다. (아래의 merge 함수)

function merge(leftA, rightA) { // 병합 함수
  var results = [], leftIndex = 0, rightIndex = 0;

  while (leftIndex < leftA.length && rightIndex < rightA.length) {
    if (leftA[leftIndex] < rightA[rightIndex]) {
      results.push(leftA[leftIndex++]);
    } else {
      results.push(rightA[rightIndex++]);
    }
  }
  var leftRemains = leftA.slice(leftIndex),
  rightRemains = rightA.slice(rightIndex);

  return results.concat(leftRemains.concat(rightRemains));
}

function mergeSort(array) {
  if (array.length<2){
    return array;
  }
  var midpoint = Math.floor((array.length)/2),
  leftArray = array.slice(0, midpoint),
  rightArray = array.slice(midpoint);

  return merge(mergeSort(leftArray), mergeSort(rightArray)); // left와 right로 계속 분할
}

계수 정렬 (count sort)

값을 비교하지 않기 때문에 O(k+n)시간 안에 수행된다.
숫자에 대해서만 동작하며, 특정 범위가 주어져야 한다.
배열의 각 항목의 등장 횟수를 세어 해당 등장 횟수를 사용해서 새로운 배열을 생성한다.
주로 제한된 범위의 정수를 정렬할 때 가장 빠른 정렬 방법이기 때문에 계수 정렬을 사용한다.
시간복잡도: O(k+n), 공간복잡도: O(k)

function countSort(arr) {
  var hash = {}, countArr = [];
  for (var i=0; i<arr.length; i++) {
    if (!hash[arr[i]]) {
      hash[arr[i]] = 1;
    } else {
      hash[arr[i]]++;
    }
  }
  for (var key in hash) { // 항목이 몇개가 되든 해당 항목을 배열에 추가한다
    for (var i=0; i<hash[key]; i++) {
      countArr.push(parseInt(key)); // key 를 hash[key] 값만큼 arr에 push한다.
    }
  }
  return countArr;
}

자바스크립트 내장 정렬

자바스크립트는 배열 객체에 사용 가능한 내장 메소드 sort()가 존재하며, 이는 항목들을 오름차순으로 정리한다.

var arr = [12, 3, 4, 2, 1, 34, 23];
arr.sort(); // [1, 12, 2, 23, 3, 34, 4]

요약

알고리즘	시간 복잡도	공간 복잡도
빠른 정렬(quick sort)	O(nlog_2(n))	O(nlog_2(n))
병합 정렬(merge sort)	O(nlog_2(n))	O(nlog_2(n))
거품 정렬(bubble sort)	O(n^2)	O(n^2)
삽입 정렬(insertion sort)	O(n^2)	O(n^2)
선택 정렬(select sort)	O(n^2)	O(n^2)
계수 정렬(count sort)	O(k+n)	O(k)

JS 자료구조&알고리즘 (3)

Eunbae — Sun, 3 Jul 2022 22:57:57 +0900

7장. 자바스크립트 메모리 관리

메모리 누수

자바스크립트는 타언어와는 달리 프로그래머가 직접 메모리를 수동으로 할당하고 해제하지 않고 사용하지않는 변수, 즉 메모리를 삭제해주는 가비지 컬렉터가 있기 때문에 매니지드언어라고 부른다. 하지만 이러한 기능에도 메모리가 올바른 방식으로 해제되지 않아 메모리 누수가 발생할 수 있기 때문에 이를 피하기위한 여러 방법이 존재한다.

객체에 대한 참조

var foo = {
	bar1: memory(), // 5kb
    bar2: memory(), // 5kb
}

function clickEvent() {
	alert(foo.bar1[0]);
}

객체에 대한 참조가 있다면 해당 참조는 메모리에 존재하는 것이다. foo객체가 bar1만을 참조하더라도 foo객체 전체를 clickEvent() 함수의 범위에 로딩해야 하기 때문에 실제로는 5KB가 아니라, 10KB의 메모리를 사용한다.

DOM 메모리 누수

DOM 항목을 가리키는 변수가 이벤트 콜백 외부에 선언된 경우 해당 DOM 항목을 제거하더라도 해당 항목은 여전히 메모리에 남게된다.

var one = document.getElementById("one");
var two = document.getElementById("two");

one.addEventListner('click', function() {
    two.remove();
    console.log(two); // 삭제 후에도 html을 출력한다(참조 유지)
}

위 코드에서 웹페이지의 two항목은 사라지지만, 해당 DOM이 HTML에서 사라지더라도 해당 DOM이 이벤트 콜백에서 사용되었다면 참조는 남는다. 이렇게 two 항목이 더 이상 사용중이 아닌경우를 '메모리 누수'라 부르며 미리 누수를 피해야한다. 따라서 아래와 같은 코드를 작성할 수 있다.

var one = document.getElementById("one");

one.addEventListner('click', function() {
    var two = document.getElementById("two"); // DOM항목을 이벤트 콜백 내부에서 사용한다.
    two.remove();
}
one.removeEventListner('click', function () {
    one.addEventListener('click', callBackExample);
}); // 또는 클릭 핸들러를 사용한 뒤 등록 해지하는 방법도 있다.

window 전역 객체

객체가 window 전역 객체에 포함되는 경우 해당 객체는 메모리에 존재하는 것이고, window의 속성으로 선언된 추가적인 객체는 모두 제거할 수 없다. window는 브라우저가 실행하는데 필요한 객체이기 때문이다. 따라서 가능하면 전역변수는 사용하지 않는 것이 좋다.

객체 참조 제한하기

객체에 대한 모든 참조가 제거되면 해당 객체는 제거되기 때문에 함수에는 객체의 전체범위가 아닌 필요한 범위, 속성만 전달해야한다.

var test = { prop1: 'test' };

function printProp(test) {
    console.log(test.prop1); // x
    console.log(test) // o
}

printProp(test); // x
printProp(test.prop1); // o

delete 연산자

원치 않는 객체 속성을 제거하기 위해 delete 연산자를 사용할 수 있다. 이때 delete 연산자는 객체에서만 동작한다.

var test = { prop1: 'test' };

console.log(test.prop1); // test

delete test.prop1;

console.log(test.prop1); // undefined

About Me

Eunbae — Fri, 1 Jul 2022 00:02:05 +0900

test

모던 자바스크립트 Deep Dive - 04. 변수

Eunbae — Thu, 30 Jun 2022 23:57:17 +0900

4.1 변수란 무엇이고, 왜 필요한가?

자바스크립트 엔진이 10+20 이라는 식의 의미를 해석하면 + 연산을 수행하기 위해서 10과 20이라는 숫자 값(피연산자)을 기억한다.

컴퓨터는 연산(CPU)과 기억(Memory)을 수행하는 부품이 나누어져 있기 때문에 피연산자 값은 메모리주소에 저장되고, CPU는 이 값을 읽어 들여 연산을 수행한다.

연산 결과로 생성된 숫자 값 30도 메모리 주소에 저장되는데 이 값을 재사용하려면 주소를 통해 메모리 공간에 직접 접근해야하지만, 이는 치명적 오류를 야기하는 매우 위험한 방법이기에 자바스크립트는 개발자의 직접적인 메모리 제어를 허용하지 않는다. 따라서 30이라는 값은 재사용이 불가능하다.

만약 직접적인 메모리 제어를 허용하더라도 코드가 실행될 때마다 값이 저장될 메모리 주소는 변경되므로, 코드 실행 이전에는 메모리 주소의 값을 알 방법이 없으므로 직접 접근하는 방법은 올바른 방법이 아니다.

프로그래밍 언어는 기억하고싶은 값을 메모리에 저장하고, 저장된 값을 읽어들여 재사용하기 위해 "변수"라는 메커니즘을 제공한다.

변수는 하나의 값을 저장하기 위해 확보한 메모리 공간 자체 또는 그 메모리 공간을 식별하기 위해 붙인 이름을 말한다.

변수는 프로그래밍 언어의 컴파일러 또는 인터프리터에 의해 값이 저장된 메모리 공간의 주소로 치환되어 실행된다. 따라서 변수를 통해 직접적인 메모리 제어 없이 안전하게 값에 접근할 수 있다!

변수에 값을 저장하는 것을 할당(assignment-대입, 저장)이라 하고, 변수에 저장된 값을 읽어 들이는 것을 참조(reference)라고 한다.

-> 변수 이름을 이용해서 참조를 요청하면, 자바스크립트 엔진은 변수 이름과 매핑된 메모리 주소를 통해 메모리 공간에 접근해서 저장된 값을 반환한다.

4.2 식별자

변수 이름을 식별자(identifier)라고도 하며, 어떤 값을 구별해서 식별할 수 있는 고유한 이름을 말한다.

식별자는 값이 저장되어 있는 메모리 주소와 매핑관게를 맺으며, 이 매핑 정보도 메모리에 저장되어야 한다!

식별자는 값이 아니라 메모리 주소를 기억하고있으며, 식별자는 메모리 주소에 붙인 이름이라고 할 수 있다.

4.3 변수 선언

변수 선언은 값을 저장하기 위한 메모리 공간을 확보하고, 변수 이름과 확보된 메모리 공간의 주소를 연결해서 값을 저장하도록 준비하는 것이다. 확보된 메모리 공간은 확보가 해제되기 전까지 누구도 확보된 메모리 공간을 사용할 수 없도록 보호되므로 안전히 공간을 사용할 수 있다.

변수를 사용하려면 선언이 반드시 필요하며 var, const, let 키워드를 사용한다. let과 const는 ES6에서 도입된 키워드로, var 키워드의 함수 레벨 스코프 지원 등의 단점을 보완하기 위해 등장한 키워드이다.

4장에서는 우선 var키워드를 살펴본다. var 키워드의 변수 선언 과정을 살펴보자.

var score; 의 변수 선언문은 변수 이름을 등록하고, 값을 저장할 메모리 공간을 확보한다. (선언 단계)
변수는 선언되었지만 아직 값은 할당되지 않았다. 이때 메모리 공간은 비어있지 않고, 확보된 메모리 공간에는 자바스크립트 엔진에 의해 undefined라는 값으로 암묵적으로 할당되어 초기화된다! (초기화 단계)

일반적으로 초기화란 변수가 선언된 이후 최초로 값을 할당하는 것을 의미한다.

만약 초기화 단계를 거치지 않으면 확보된 메모리 공간에는 이전에 다른 앱이 사용했던 값이 남아있을 수 있는데, 이 값을 쓰레기값(garbage value)라 한다. 이러한 쓰레기 값을 참조하는것을 방지하기 위해 var 키워드는 암묵적으로 초기화를 수행한다.

4.4 변수 선언의 실행 지점과 변수 호이스팅

console.log(score); // undefined

var score; // 변수 선언문

위 코드를 살펴보면 변수 선언문보다 변수를 참조하는 코드가 앞에 있지만, 인터프리터에 의해 한 줄씩 순차적으로 코드가 실행되는 과정에서 참조 에러가 발생하지 않고 undefined가 출력된다.

-> 이는 변수 선언이 소스코드가 순차적으로 실행되는 시점(런타임)이 아니라 그 이전단계(소스코드의 평가과정)에서 먼저 실행되기 때문이다! 소스코드의 평과과정에서는 변수, 함수 선언문 등을 소스코드에서 찾아내 먼저 실행하고, 이 과정이 끝나면 모든 선언문을 제외하고 소스코드를 한 줄씩 순차적으로 실행한다.

이처럼 변수 선언문이 런타임 이전단계에서 먼저 실행되어 코드의 선두로 끌어올려진 것 처럼 동작하는 자바스크립트 고유의 특징을 변수 호이스팅이라 한다.

; var, let, const, function, class등의 키워드를 사용해서 선언하는 모든 식별자는 런타임 이전단계에서 실행되기 때문에 모두 호이스팅된다고 할 수 있다.

4.5 값의 할당

변수에 값을 할당할 때는 할당 연산자 "="를 사용한다. 할당 연산자는 우변의 값을 좌변의 변수에 할당한다.

var score; // 변수 선언
score = 80; // 값의 할당

var score = 80; // 변수 선언 + 값의 할당

위 코드와 같이 변수 선언과 값의 할당을 2개의 문으로 나누어 표현할 수도 있고, 하나의 문으로 단축하여 표현할 수도 있다.

두가지 표현 방식은 정확히 동일하게 동작하고, 이는 하나의 문으로 단축 표현해도 자바스크립트 엔진은 변수 선언과 값의 할당을 2개의 문으로 나누어 각각 실행한다는 것이다.

이 때 변수 선언은 런타임 이전에 먼저 실행되지만, 값의 할당은 소스코드가 순차적으로 실행되는 시점인 런타임에 실행된다!

변수에 값을 할당할 때는 이전 값 undefined(초기화된 값)가 저장되어 있던 메모리 공간을 지우고 할당값을 저장하는 것이 아니라, 새로운 메모리 공간을 확보하고 그곳에 할당 값을 저장한다는 점을 주의해야 한다.

4.6 값의 재할당

var score = 80;
score = 90; // 값의 재할당

위 코드와 같이 var 키워드로 선언한 변수는 값을 재할당할 수 있다. 재할당은 현재 변수에 저장된 값을 버리고 새로운 값을 저장하는 것이다. (엄밀이 말하면 변수를 선언 후 초기화하는 과정도 재할당이라 할 수 있다.)

처음 변수에 값을 할당할 때와 마찬가지로 이전 값 80이 저장되어있던 메모리 공간을 지우고 90을 저장하는것이 아니라, 새로운 메모리 공간을 확보하고 그 메모리 공간에 90을 저장한다!

score변수의 이전 값인 undefined와 80은 아무도 사용하지 않는 필요하지 않은 값이므로 이 값들은 가비지 콜렉터에 의해 특정 시점에 메모리에서 자동 해제된다.

가비지 콜렉터는 어플리케이션이 할당한 메모리 공간을 주기적으로 검사하여 더 이상 사용되지 않는 메모리를 해제하는 기능이다. 자바스크립트는 가비지 콜렉터를 내장하고있는 매니지드 언어로서 메모리 누수를 방지한다. (언매니지드 언어에는 개발자가 명시적으로 메모리를 할당하고 해제할 수 있는 c언어가 있다.)

요약

변수는 하나의 값을 저장하기 위해 확보한 메모리 공간 자체 또는 그 메모리 공간을 식별하기 위해 붙인 이름을 말한다.
변수는 식별자라고도 하며, 식별자는 값이 아니라 메모리 주소를 기억하고있고 메모리 주소에 붙인 이름이라고 할 수 있다.
변수는 선언과정에서 선언단계와 초기화단계를 거친다.
변수 선언문이 런타임 이전단계에서 먼저 실행되어 코드의 선두로 끌어올려진 것 처럼 동작하는 자바스크립트 고유의 특징을 변수 호이스팅이라 한다.
변수 선언은 런타임 이전에 먼저 실행되지만, 값의 할당은 소스코드가 순차적으로 실행되는 시점인 런타임에 실행된다.
변수에 값을 (재)할당할 때는 이전 값이 저장되어 있던 메모리 공간을 지우고 할당값을 저장하는 것이 아니라, 새로운 메모리 공간을 확보하고 그곳에 할당 값을 저장한다.

JS 자료구조&알고리즘 (2)

Eunbae — Thu, 30 Jun 2022 16:14:55 +0900

5장. 자바스크립트 배열

배열

삽입

새로운 항목을 자료 구조 내에 추가하는것. .push(element)메소드를 사용해 배열 삽입을 구현할 수 있다.

var arr = [1, 2, 3, 4]
arr.push(5); // arr = [1, 2, 3, 4, 5]
arr.push(8); // arr = [1, 2, 3, 4, 5, 8]

// 시간복잡도: O(1)

삭제

.pop()메소드를 사용해 배열 삭제를 구현할 수 있다. 해당 메소드는 제거된 항목을 반환한다.

var arr = [1, 2, 3, 4]
arr.pop(); // return 4, arr = [1, 2, 3]

// 시간복잡도: O(1)

arr.shift(); // return 1, arr = [2, 3]
// shift()는 첫번째 항목을 제거한 다음 해당 항목을 반환한다.

접근

특정 인덱스의 배열에 접근하는 연산은 인덱스를 이용해서(0부터 시작) 메모리의 주소로부터 직접 값을 얻기 때문에 시간 복잡도가 O(1)이다.

var arr = [1, 2, 3, 4]
arr[1] // return 2
arr[3] // return 4

반복

반복은 어떤 자료구조 내에 담긴 항목들을 하나씩 접근하는 과정이며 모두 O(n)의 시간복잡도를 가진다.

for (변수; 조건; 수정)

for은 변수 i를 초기화하고 코드 실행 전 조건이 거짓인지 확인한다. 만약 거짓이라면 변수를 수정

하며 동작한다.

for (var i=0, len=arr.length; i<len; i++) {
	console.log(arr[i])
}

while

var counter = 0;
while(counter<arr.length){
	// ~
    counter++
} //while은 counter가 루프의 바깥에서 초기화되어야 한다.

무한 루프

while(true){
	if(breakCondition) {
   		break;
	}
}

for(;;) {
	if(breakCondition) {
   		break;
	}
} //조건을 설정하지 않음으로써 무한루프를 구현할 수 있다.

for (in)

인덱스를 하나씩 호출하는 배열을 반복 접근하기위한 방법으로, in 앞에 지정된 변수는 배열의 인덱스이다.

var arr = ['a', 'b', 'c', 'd']

for (var index in arr) {
	console.log(index)
} // 0, 1, 2, 3

for (of)

of 앞에 지정된 변수는 배열의 항목(값)이다.

var arr = ['a', 'b', 'c', 'd']

for (var element of arr) {
	console.log(element)
} // a, b, c, d

forEach()

forEach는 반복 중 바깥으로 빠져나오거나 배열 내의 특정 항목을 건너뛸 수 없다. 따라서 반복 접근한다는 의미에 있어 조금 더 명시적이라 할 수 있다.

var arr = ['a', 'b', 'c', 'd']

arr.forEach( function (element, index) {
	console.log(element, index)
} // a 0, b 1, c 2, d 3

도움 함수

.slice(begin, end)

기존 배열을 수정하지 않고 해당 배열의 일부를 반환하며, 시작과 끝 인덱스를 매개변수로 받는다.

var arr = [1, 2, 3, 4];
arr.slice(0, 2) // return [1, 2]
arr.slice(1) // return [2, 3, 4]
arr.slice() // return [1, 2, 3, 4]

.slice()는 배열 전체의 복사본을 반환하기 때문에 배열을 복사하는데 유용하다. 배열에 신규변수를 할당하면 기존변수를 '참조'하기때문에 신규변수를 변경하면 기존변수에도 변경점이 의도치않게 적용될 수 있다. 새로운 배열을 만드려면 .from()이나 .slice()등을 이용해야 한다.

var arr1 = [1, 2, 3], arr2 = arr1;

arr2[0] = 5;
console.log(arr1) // [5, 2, 3]
console.log(arr2) // [5, 2, 3]
// arr2는 arr1을 참조한다.

var arr3 = [1, 2, 3];
var arr4 = Array.from(arr3);
var arr5 = arr3.slice();
// arr4와 arr5는 새로운 배열로 생성된다.

.splice(begin, size, element1, element2, ...)

.splice()는 기존 항목을 제거하거나 신규 항목을 추가함으로써 배열의 내용을 반환하고 변경한다.

-> .splice(시작 인덱스, 제거할 항목의 크기, 추가할 신규항목들...)

var arr = [1,2,3,4];
arr.splice(); // return [], arr = [1,2,3,4]
arr.splice(1, 2); // return [2, 3], arr = [1, 4]
arr.splice(1, 2, 7, 7, 7) // return [2, 3], arr = [1,7,7,7,4]
arr.splice(1, 2, { 'ss': 1 }) // return [2, 3], arr = [1, { 'ss': 1 }, 4]

.concat()

신규 항목을 배열의 맨 뒤에 추가한 다음 해당 배열을 반환한다.

var arr = [1,2,3,4];
arr.concat() // return [1,2,3,4], arr = [1,2,3,4]
arr.concat([6, 6, 6]) // return [1,2,3,4,6,6,6], arr = [1,2,3,4]
// concat은 기존 배열은 바꾸지 않음

.length 속성

배열의 크기로 반환한다. 배열을 더 작은 크기로 변경하면 배열에서 항목들이 제거된다.

var arr = [1,2,3,4];
console.log(arr.length) // 4
arr.length = 3; // arr = [1,2,3]

전개(spread) 연산자

점 3개(...)로 표현하며 인자를 확장하는데 사용한다.

var arr = [1,2,3,4];
function addFourNums(a, b, c, d) {
	return a+b+c+d;
}
console.log(addFourNums(...arr)); // 10

Math.max와 Math.min

두 함수 모두 무한개의 매개변수를 받을수 있으며 spread연산자를 사용하면 배열의 최댓값과 최솟값을 찾을 수 있다.

var arr = [3, 2, -123, 1234, 12];
Math.max(...arr); // 1234
Math.min(...arr); // -123

6장. 자바스크립트 객체

자바스크립트 객체 속성

자바스크립트에서는 객체 상수 {} 또는 new Object(); 구문을 통해 객체를 생성할 수 있다.

속성을 추가하거나 접근하기 위해서는 objcet.propertyName 또는 object['propertyName']을 사용할 수 있다.

var jsObj = {};
var arr = [1,2,3,4];
jsObj.array = arr;
console.log(jsObj); // {array: [1,2,3,4]}

jsObj['title'] = 'Algorithms';
console.log(jsObj); // {array: [1,2,3,4], title: 'Algorithms'}

프로토타입 활용 상속

자바스크립트에서는 함수가 클래스의 자바스크립트 Object속성으로 추가되어야 한다.

function ExampleClass() {
	this.name = "js";
    this.sayName = function() {
		console.log(this.name);
}

var example1 = new ExampleClass();
example1.sayName(); // "js"

위 코드의 class는 생성자에서 sayName함수를 동적으로 추가하는데, 이러한 패턴을 프로토타입 활용 상속이라고 한다. 이 상속은 자바스크립트에서 유일한 상속 방법이며 클래스에 함수를 추가하기 위해서는 .prototype 속성을 사용한 후 함수의 이름을 지정하기만 하면 된다.

function ExampleClass() {
	this.arr = [1,2,3];
    this.name = "js";
}

var example1 = new ExampleClass();

ExampleClass.prototype.sayName = function() {
	console.log(this.name);
}
example1.sayName(); // "js"

-> 함수를 클래스에 동적으로 추가하는 방식이 자바스크립트가 프로토타입 활용 상속을 구현하는 방식이다.

JS 자료구조&알고리즘 (1)

Eunbae — Wed, 29 Jun 2022 16:30:58 +0900

배세민, ⌜자바스크립트로하는 자료구조와 알고리즘⌟, 에이콘, 2019
- 요약 및 배운점 정리

1장. 빅 오 표기법

빅오 표기법이란?

빅오 표기법은 알고리즘의 최악의 경우 복잡도를 측정하는 방법이다. 빅오 표기법에서 n은 입력의 개수를 나타내며, 알고리즘 구현시 해당 알고리즘이 얼마나 효율적인지를 나타낼 수 있는 방법이기에 중요하다!

빅오 표기법은 O()로 나타낼 수 있는데 O(1)은 상수시간, 즉 입력 공간에 대해 변하지 않음을 나타내고 O(n)은 선형시간으로 최악의 경우에 n번의 연산을 수행해야하는 알고리즘이 이에 해당한다.

빅오 표기법의 규칙

알고리즘의 시간 복잡도를 f(n)이라 표현한다. f(n)을 계산함으로써 알고리즘의 효율성을 이해할 수 있지만 계산이 어려울 수 있기 때문에 이에 도움이 되는 기본적인 여러가지 규칙이 존재한다.

계수 법칙 - "상수를 제거하라"

상수 k > 0인 경우 f(n)이 O(g(n))이면 kf(n)은 O(g(n))이다.

n과 관련되지 않은 계수는 제거하는 규칙으로, 5f(n)과 f(n)은 모두 동일한 O(f(n))이다.

-> f(n) = 5n, f(n) = n + 1인 경우는 모두 O(n)의 빅오표기법이다.

합의 법칙 - "빅오를 더하라"

코드에서 f(n)=n과 f(n)=4n이 각각 실행된다면 합의 법칙에 의해 f(n) = 5n이다. 이때 계수법칙에 의해 최종적 결과는 O(n)=n이다.

곱의 법칙 - "빅오를 곱하라"

코드에서 루프에 의해 5n번 실행되고 내부 루프가 외부 루프에의해 n번 실행된다면 f(n) = 5n x n이다. 이때 계수법칙에 의해 O(n) = n^이다.

다항 법칙 - "빅오의 k승"

f(n)이 k차 다항식이면 f(n)은 O(n^k)이다.

...
for (var i=0; i<n*n; i++) {
	conut+=1;
}
// count+=1;이 n*n번 실행되기 떄문에 f(n)=n^2이다.

2장. 자바스크립트의 독특한 특징

자바스크립트 범위

범위(scope)는 자바스크립트 변수에 대한 접근 권한을 정의하는 것이다. 자바스크립트에서 변수는 전역 범위 또는 지역 범위에 속할 수 있다.

전역 범위 - 연산자 없이 변수를 선언하게되면 전역변수를 생성함
함수 범위 - var

- 변수 호이스팅 (variable hoisting) : var를 사용하여 변수를 선언하면 어디에서 선언하든 변수 선언이 함수의 맨 앞으로 이동한다.

function scope(print){
	if(print){
    	var insideIf = '12';
    }
    console.log(insideIf);
}
scope(true) // 12출력, 오류발생x

function scope(print){
	var insideIf
    
	if(print){
    	insideIf = '12';
    }
    console.log(insideIf);
}
scope(true)
//위의 함수와 동일하다. var은 함수범위로 정의되며 호이스팅이 일어난다.

블록 범위 - let, const : 변수가 선언된 { } 내에서만 유효함

function scope(print){
	if(print){
    	let insideIf = '12';
    }
    console.log(insideIf);
}
scope(true) // 12 x, ''를 출력함

등가와 형

변수형

boolean, number, string, undefined, object, function, symbol

-> 선언만 되고 값이 할당되지 않은 변수에는 undefined가 할당된다.

true / false 확인

if 내의 매개변수는 대개의 다른 언어와는 달리 꼭 boolean형이 아니어도 된다.

- false로 평가되는 경우 : false, 0, '', "", NaN, undefined, null

- true로 평가되는 경우 : true, 0이 아닌 다른 숫자, 비어있지 않은 문자열, 비어있지 않은 객체

=== vs ==

자바스크립트는 변수 선언 시 변수에 형이 할당되지 않으며, 코드가 실행될 때 해당 변수의 형이 해석된다. 따라서 ===는 ==에 비해 등가를 조금 더 엄격히 확인한다.

==: 값만 같은지 여부를 확인

===: 형과 값 모두 같은지 여부를 확인

객체

var object1 = {};
var object2 = {};

console.log(object1 == object2); //false
console.log(object1 === object2); //false

- 동일한 속성과 값을 가져도 두 변수의 메모리상 주소는 다르기 때문에 두 객체는 동일하지 않다.

var function1 = function(){console.log(2)};
var function2 = function(){console.log(2)};

console.log(function1 == function2); //false

- 동일한 연산을 수행해도 두 함수의 메모리상 주소는 다르기 때문에 두 함수는 동일하지 않다.

→ ==, ===연산자는 숫자, 문자열, 불리언과 같은 비객체형에만 사용가능하다! (객체와 함수에서는 사용x)

3장. 자바스크립트 숫자

숫자 체계

자바스크립트는 숫자에 대해 64비트 부동소수점 표현을 사용한다. 63번째 비트는 부호를, 63~52번째 비트는 지수 값 e를, 나머지 52비트는 분수 값을 나타낸다. 이 64비트값은 어려운 공식에 의해 계산되는데, 이러한 십진분수로 인하여 자바스크립트에서 부동소수점 체계가 반올림 오류를 일으킬 수 있다. 이러한 이유 때문에 0.1과 0.2는 정확히 표현할 수 없다. 따라서 0.1 + 0.2 === 0.3의 결과는 false이다.

자바스크립트 숫자 객체

위와같은 숫자 체계의 문제를 해결하는데 도움이 되는 Number객체의 내장된 속성이 있다

정수 반올림

자바스크립트는 정수를 정수형으로 명시적으로 선언하지 않고 모든 숫자를 표현할 때 부동소수점을 사용하기 때문에 정수 나눗셈을 하면 부동소숫점의 결과가 나온다. (5/4 = 1.25) 따라서 정수 나눗셈을 하기위해서는 아래와 같은 함수를 이용해야한다.

Math.floor()
Math.round()
Math.ceil()

Number.EPSILON

두 개의 표현 가능한 숫자 사이의 가장 작은 간격을 반환한다.

function numberEquals(x, y) {
	return Math.abs(x - y) < Number.EPSILON;
}
numberEquals(0.1 + 0.2, 0.3) // true

최대치

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true

Number.MAX_VALUE + 1 === Number.VALUE + 2; // true

Number.MAX_SAFE_INTEGER: 가장 큰 정수를 반환

Number.VALUE: 가장 큰 부동소수점 수를 반환

최소치

Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER -2; // true

Number.MIN_VALUE -1 == -1; // true

Number.MIN_SAFE_INTEGER: 가장 작은 정수를 반환

Number.MIN_VALUE: 가능한 가장 작은 부동소수점 수를 반환 -> 음수가 아님! (Number.MIN_SAFE_INTEGER < Number.MIN_VALUE)

무한

Infinity > Number.MAX_SAFE_INTEGER; // true
-Infinity < -Number.MAX_SAFE_INTEGER; // true
-Infinity - 32323323 == -Infinity - 1; //true: -Infinity보다 작아질 수 있는것은 없음

크기 순서

-Infinity < Number.MIN_SAFE_INTEGER < Number.MIN_VALUE < 0 < Number.MAX_SAFE_INTEGER < Number.MAX_VALUE < Infinity

무작위 수 생성기

자바스크립트에는 숫자를 생성하기 위핸 내장 함수인 Math.random()이 있다. 이 함수는 0과 1 사이의 무작위 부동 소수점을 반환한다.

4장. 자바스크립트 문자열

자바스크립트 문자열 기본

문자열 접근

문자에 접근하기 위해 .charAt(index)을 사용할 수 있다.

'dog'.charAt(1); // "o"

문자열 접근을 위해 .subString(startIndex, endIndex)을 사용할 수 있다. subString은 지정된 인덱스 사이의 문자들을 반환한다. endIndex를 전달하지 않으면 지정된 시작위치부터 끝까지 모든 문자를 반환한다.

'YouTube'.substring(1,2) // 'o'
'YouTube'.substring(3,6) // 'Tub'
'YouTube'.substring(2) // 'uTube'

문자열 비교

자바스크립트에서는 < 와 >를 이용하여 쉽게 문자열을 비교할 수 있다.

console.log('a' < 'b') // true
console.log('abb' < 'b') // true
console.log('add' < 'ab') // false

문자열 검색

문자열 내에 특정 문자열을 찾기위해 .indexOf(searchValue[, fromIndex])를 사용할 수 있다. 일치하는 문자열을 찾으면 위치를 반환하고, 찾지 못한다면 -1을 반환한다.

'Red Dragon'.indexOf('Red') // 0
'Red Dragon'.indexOf('Dragon') // 4
'Red Dragon'.indexOf('Blue') // -1
'Red Dragon'.indexOf('Dragon', 2) // 4
'Red Dragon'.indexOf('Dragon', 6) // -1
'Red Dragon'.indexOf('', 9) // 9

startWith는 문자열이 특정 입력으로 시작하면 true를 반환하고, endsWith는 끝나면 true를 반환한다.

'Red Dragon'.startsWith('Dragon') //false
'Red Dragon'.endsWith('Dragon') //true

문자열 분해

문자열을 여러 부분으로 나누기 위해 .split(separator)를 사용할 수 있다. separator를 입력받으면 부분 문자열 배열(Arr)를 생성한다.

'chicken,cow,pig'.split(","); // ["chicken", "cow", "pig"]
'chicken'.split(""); // ["c", "h", "i", "c", "k", "e", "n"]

문자열 바꾸기

.replace(string, replaceString) 문자열 변수 내에 특정 문자열을 다른 문자열로 대체할 수 있다.

"Red Dragon".replace("Red", "Blue"); // "Blue Dragon"

OS - 06. Deadlock

Eunbae — Tue, 28 Jun 2022 14:00:40 +0900

Preemptable and Nonpreemptable Resources

이벤트들은 작업에따라 resource를 필요로 한다.

Request the resource
Use the resource
Release the resource

Resource Acquisition

a: 하나의 리소스를 사용하는 경우. 리소스를 할당받기위해 semaphore을 설정하고 down > use > up을 통해 사용 후 반납한다.

b: 리소스 2개를 사용하는경우. 리소스를 둘 다 할당받은 후 사용 후 둘 다 반납한다.

a: deadlock free code. 자원의 할당 및 반납순서를 지켜 데드락이 발생하지 않는다.

b: code with a potential deadlock. pA가 resource1을 할당받고 pB가 resource2를 할당받게되면 서로 resource 2,1을 기다리게되므로 데드락이 발생할 수 있다.

Illustation

-> 데드락은 각각의 프로세스가 다른 프로세스의 작업이 수행완료될때까지 기다리는 경우 발생할 수 있다!

Conditions for Resource Deadlocks

Mutual exclusion condition
Hold and wait condition
No preemption condition
Circular wait condition

Deadlock Modeling

Strategies for deadlock

Just ignore the problem - 무시한다. 실제로 대부분의 시스템이 사용한다
Detection and recovery - deadlock을 확인하고 회복한다. 프로세스를 죽여서 할당할 수 있다.
Dynamic avoidance - deadlock 회피전략.
Prevention - deadlock일어나는 4가지경우 중 1가지 경우를 아예 없애버린다.

Deadlock Detection

Deadlock Detection; with One Resource of Each Type

어떤 자원이 어디에 할당되어있는지 resource graph를 그려 circle만 남겨서 데드락이 발생하는 b 경우를 파악한다.

- P1을 처리하면 사용가능한 자원은 2 3 1 로 p1을 끝낼 수 있다. 하지만 p4를 처리하면 사용 가능한 자원이 0 0 3이 남게되므로 처리가능한 프로세스는 존재하지 않기 때문에 deadlock이 발생한다.

- 이렇게 deadlock이 발생하는 경우를 회피해서 실행 순서를 정할 수 있다.

Recovery from Deadlock

Recovery through preemption
Recovery through rollback
Recovery through killing processes

preemption을 뺏거나 프로세스를 rollback, killing하여 자원을 뻇어서 할당함으로써 recovery할 수 있다.

Deadlock Avoidance

Deadlock을 피해다니면서 할당한다.

b의 경우는 C를 끝낼 수 있으므로 deadlock이 발생하지 않지만, c는 끝낼 수 있는 프로세스가 존재하지 않으므로 deadlock이 발생한다.

Deadlock Prevention

Deadlock Prevention의 접근방법

Attacking Mutual exclusion, Hold and wait, No preemption, Circular wait의 4가지 경우 중 한 경우를 없애버리면 deadlock이 발생하지 않을 수 있다. 이 접근법에는 위의 그림과 같다.

OS - 05. Input / Output

Eunbae — Tue, 28 Jun 2022 13:58:17 +0900

Block Device & Character Device

Block Device

- Read/Write Unit: Block(입출력 단위: Block)

- block마다 주소가 존재하며 HDD, CD-ROM, USB등이 있다.

Character Device

- Read/Write Unit: Char(입출력 단위: Char)

- 각 char는 주소가 없으며 Mouse, Printer, Modem, Keyboard등이 있다.

Device Controllers

Block Device

- Read/Write Unit: Block(입출력 단위: Block)

- block마다 주소가 존재하며 HDD, CD-ROM, USB등이 있다.

Device Controller

- 각 device들은 여러 device들을 다루도록 도와주는 device controller가 존재한다.

- controller는 CPU에 interrupt를 보내거나 block을 bit로 변환하거나 buffer를 관리하는 등의 작업을 수행한다.

Memory Bus Architecture

single bus/ dual bus architecture. dual-bus로 구성하면 전용 버스가 생기므로 메모리 접근 속도가 빨라진다.

Direct Memory Access (DMA)

프로그램이 디스크로부터 데이터를 읽기 위해서는 CPU와 디스크의 속도차이가 존재하기 때문에 DMA controller를 통해 데이터를 접근한다. CPU가 디스크의 데이터를 읽으려면 DMA Controller에게 주소와 count등의 정보를 넘겨주면 스스로 interrupt한다. DMA Controller는 CPU에게 전달받은 정보를 바탕으로 동작을 수행하여 값을 읽어와 버퍼에 넣는다. 버퍼에 가져온 데이터는 Cycling Stealing(Bus transfer mode)을 통해 CPU-Memory간의 버스를 이용하여 메인 메모리에 데이터를 copy한다. 작업이 완료되었다면 CPU는 꺠어나 메인 메모리의 데이터를 이용하여 작업을 계속 수행한다.

Interrupts Revisited

bus에 interrupt 라인이 존재하여 CPU에 신호를 보낼 수 있으며 CPU는 신호를 받으면 현재 실행하는 명령까진 실행 한 후 멈추고 다른작업을 한다.

interrupt controller는 I/O device의 작업이 수행이 끝나면
CPU에 interrupt를 발생시킨다.
CPU는 interrupt가 끝났다는 신호를 보낸다.

Precise and Imprecise Interrupts

precise interrupt의 속성

PC(Program Counter)는 알려진 장소에서 저장되어야한다.
PC이전에는 모두(fully) 실행되어야한다.
PC 이후는 하나도 실행되지 않은 상태여야한다.
PC가 가리키는 위치는 정확히 알아야한다.

- Precise interrupt - PC 이전에는 모두 실행되며 이후에는 한개도 실행되지 않은 상태.

- imprecise interrupt - 아주 많은 명령이 조금씩 실행된 상태. 이 상태를 그대로 저장 및 복구해서 실행하는것은 어렵기 때문에 현실은 a방식으로 동작하게 한다.

Goal of I/O Software

Device Independency : 각 device는 독립적이어야한다.
Uniform Naming : 디바이스마다 이름이 지정되어야한다.(OS가 해준다)
Error Handling : 버퍼또는 메모리가 없는경우 등에는 에러처리를 해야한다.
Synchronous vs asynchronous : 동기적으로 처리(입력후멈추고 하나씩 처리되기를 기다림)하면 속도가 느려지므로 디바이스는 대부분 비동기적인 방식을 사용한다.
Buffering : 디바이스의 데이터는 OS 내부의 버퍼로 데이터를 가져와서 프로그램(CPU)에 copy하여 전해진다.
Sharable vs dedicated devices : disk는 공유가능하다.

Buffering

user space의 데이터를 OS의 버퍼로 옮기고, DMA회로를 통해 네트워크 컨트롤러 카드의 버퍼로 옮긴다. 이 데이터를 네트워크를 통해 전송한 뒤 반대의 과정이 일어난다. 5번의 많은 copy가 발생한다!

Magnetic Disks

RAID(Redundant Array of Independent Disk)

Data를 strip단위로 쪼개어 여러개의 디스크를 하나의 디스크처럼 사용하기위해 묶어주는 방법이다.

a: RAID level 0

b: RAID level 1, 왼쪽의 disk strip들을 그대로 오른쪽에 복제하여 저장하는 방법이다.(미러링) 하지만 이 방법은 비용이 증가할 수 있다.

c: RAID level 2, bit 1~4를 fraction하여 저장한다. 만약 bit4가 고장났다면 1~3과 5~7을 읽어 복구할 수 있다.

d: RAID level 3, 4bit를 쪼개서 parity를 적는다. 만약 bit4가 고장났다면 나머지 bit와 parity를 읽어서 복구할 수 있다.

e: RAID level 4, strip 0~3으로 나누어 parity를 strip 묶음마다 저장한다.

f: RAID level 5, level 4에서 parity disk는 자주 참조될 수 있으므로 여기에 parity를 분산하여 저장한다.

Disk Formatting

b: single interleaving. c: double interleaving

-> interleaving: 만약 0번 섹터를 읽고 바로 다음 1번섹터에 쓸려면 디스크가 돌아가 지나치게되어 한바퀴를 더 돌고 써야한다. 이를 방지하기위해 연속 섹터에 간격을 주어 1칸 또는 2칸씩 떨어뜨리는 방법을 사용할 수 있다.

Disk Arm Scheduling Algorithms

Read/write time factors

Seek time
Rotational delay
Actual data transfer time

Seek time dominates
Error checking is done by controllers

First-in, first-out (FIFO)

요청이 도착한 순서대로 실행하는 방법이다. 실린더 번호 순서대로 요청이 처리된다.

Shortest Service Time First

현재 헤드 위치에서 가장 가까운것을 읽는 방법이다. 다만 이 방법은 현재 헤드 위치와 먼 요청은 starvation이 일어날 수 있다는 문제가 있다.

SCAN or elevator algorithm

헤드의 트랙의 방향을 정한 후 더이상 처리할게 없으면 방향을 바꾸어 처리한다. 엘리베이터와 똑같이 작동하는 방식이다.

-> starvation이 없다! 요청들의 바깥쪽,안쪽과 중간부분의 서비스타임 편차가 존재한다(가운데 부분이 가장 서비스 많이됨)

C-SCAN (Circular-SCAN)

헤드가 양 방향으로 움직이지않고 오직 한 방향으로 움직이는 방식이다. 번호가 큰쪽으로 헤드가 이동하고, 끝까지 읽으면 다시 처음 0번부터 헤드를 빠르게 움직인 다음 서비스한다. 입출력요청이 많은 시스템에서 헤드가 움직이면 운이 좋은 트랙은 바로 서비스되지만 운이 나쁜 트랙은 (헤드가 떠난 다음 요청) 서비스 시간이 오래걸린다.

N-step-SCAN

Queue가 여러개 존재한다. 한 큐에는 최대 N개까지 요청이 오며, C-SCAN으로 가면서 큐마다 처리한다. (N개의 요청 안에서만 편차-운이 좋고 나쁜 시스템이 존재한다)

FSCAN

Queue를 2개 사용한다. 한번 서비스를 시작했으면 이 후에 서비스 요청이 왔다면 다른 큐에 매달리고, 한 큐가 끝나면 다른 큐를 서비스하며 번갈아가며 실행한다.

Error Handling

-> 트랙마다 spare 섹터가 존재하여서 Bad sector가 있다면 이 공간으로 교체한다.(b) 또는 한 섹터씩 미뤄서 섹터를 연속적으로 만들 수도 있다.(c)

Stable Storage

b: ECC error(변경하다 죽음) ~ crash가 발생하면 a상태로 복구하고, crash가 발생하지 않으면 c상태가 된다.

d: 마찬가지로 crash가 발생하면 1번 disk를 copy하여 e상태가 된다.

(새로운 데이터를 기록하다가 crash가 나면 나중에 데이터를 읽어보다가 ECC에 에러를 확인한다.)

OS - 04. File systems (2)

Eunbae — Tue, 28 Jun 2022 13:54:05 +0900

File System Backups

백업은 disaster(재난), stupidity(실수)에 의한 Recover(복구)하기위해 사용되는 방법이다.

Backup Type에는 Physical Dump, Logical Dump가 있다.

- Physical Dump: 하드디스크 등을 끝까지 통채로 tape에 copy하는 방식이다.

- Logical Dump: tree등을 순회하며 파일들을 copy하는 방식이다.

- Complete Dump: 파일들을 통채로 copy한다.

- Incremental Dump: 마지막 dump이후 변경된 파일만 copy한다.

색칠된 부분이 dump(작업중이던 메모리 상태를 저장)할 부분. 색칠 부분의 상위 directory도 dump해야한다. (1, 5, 6, 7, ...)

Other considerations

- Recovery from Backup

: 마지막으로 dump된 지점에서 복구하는 방법이다.

- Problems of logical dump ~ 문제점

: File links는 두번 dump된다.(backup 프로그램은 둘 다 오리지널이므로 구분할 수 없다.)

UNIX files에서는 할당되지 않은 블록의 데이터(data block이 없으면 OS는 모두 0으로 채워서 반환함)도 모두 copy하여 백업 용량이 커진다.

File system consistency

- multiple block을 업데이트 할 때 또는 system crash(전기 x)가 일어날 때 일관성에 문제가 발생할 수 있다.

- File system consistency를 유지하는 Utility에는 UNIX: fsck, Windows: scandisk가 있다.

- 많은 현대 파일 시스템은 빠른 일관성 회복을 위해 journaling scheme을 사용한다.

Increasing file system performance

* Caching : buffer cache or block cache

- Replacement Policy: LRU, Second Chance, FIFO or others

- Meta-data는 일관성유지를 위해 쓰여진 즉시 읽혀야한다.

- MS-DOS: Write-through (변경되면 즉시 캐시와 disk에 기록), UNIX: Write-back (변경되면 캐시에만 기록, 나중에(30초 간격으로) 한번에 disk에 기록)

* Read-ahead

: sequential하게 읽어서 앞부분을 읽으면 다음 부분을 OS가 미리 캐시에 넣어둔다.

* Reducing disk arm movement

* Disk defragmentation

Caching

buffer cache data structure

- Hash table을 사용하여 캐시를 추적한다. head들이 linked list로 연결되어있다.

> 만약 10번 블록을 찾는다하면 Hash table을 사용하여 캐시를 추적하여 캐시에 존재하면 바로 참조하고, 존재하지 않으면 disk에서 찾아서 캐시에 넣고 return한다.

- i-node블록과 같은 경우는 드물게 짧은 간격에 두번 참조될 수 있다..??

- 교체정책으로 LRU를 사용하며 영화 데이터같은 경우 순서상 한번만 참조될 것 같으면 MRU말고 LRU에 넣는다. 또 Meta data는 빨리 sync해서 찾아야하고 자주 참조될 데이터는 오래 가지고 있는다.

Reducing Disk Arm Motion

Disk Arm(Head)의 움직임을 최소화하자는것이 목표.

Disk Partition에는 Cylinder Group이 존재하고, 한 그룹내에는 Super block(파일 시스템 전체정보), Group descriptor(Group에 대한 정보~어디서 어디까지 i-node인지 등) 등이 존재한다.

- 한 파일이 한 그룹에서 일정 개수이상 차지하면 인접 Group에 할당하도록(독차지하지 못하도록) 설계되어있다.

a: i-node들이 disk의 처음부분부터 적혀져있다. 이 방식은 디스크 헤드의 움직임이 많아지고, 안정성도 떨어진다.

b: i-node들이 disk의 인접 실린더 그룹에 묶여 적혀있다. 이 방식은 헤드의 움직임이 작아 성능이 높고, 안정성도 높다.

File system의 변천

The ISO 9660 File system

ISO 9660 directory entry

-> CD ROM File System이며, CD ROM은 연속적이므로 start block과 file size만 적혀있으면 된다.

Rock Ridge Extensions

UNIX에서 만든 CD ROM의 확장판. fields를 확장하였다. (여러 타입 추가, 속성 및 location등의 값 추가)

Joliet Extension

MS에서 만든 확장판. 파일 이름을 길게하고 dir 이름을 더 길게 할 수 있는 등으로 확장되었다.

File Access Control

허가없이 다른 사용자의 파일 접근을 못하도록 파일 접근 권한을 관리해야한다.

Access Control Matrix

access에 대한 정보를 담은 File과 User에 대한 행렬. 파일 시스템이 이 matrix를 보고 권한허용여부를 결정한다.

Access Control List

파일단위로 축소하여 파일마다 권한을 다 적어놓는다. UNIX가 이를 약간 변형하여 사용하였다.

Capability List

사용자를 기준으로 파일 권한에 대하여 적어놓는다. 파일 시스템에선 사용되기 어려우며 로그인, 네트워크 등의 유저권한이 중요한 부분에서 사용중인 방식이다.

File System Layout

MS-DOS FAT File System

long file name방식(다른 블록에 file name을 적는 방식)은 특허가 있어 다른 시스템에서는 사용하지 못한다.

UNIX V7 File System

UNIX는 i-node로 block을 관리한다

OS - 04. File systems (1)

Eunbae — Tue, 28 Jun 2022 13:50:44 +0900

File Systems

Requirements for long-term information storage

많은 양의 정보를 저장할 수 있어야한다.
process가 종료되더라도 정보는 남아있어야한다(비휘발성)
다수의 process가 동시에 공유 혹은 접근할 수 있어야한다.

File & File system

File

- 저장공간에 데이터 저장시 저장되는 가장 기본단위이다.(파일 단위로 저장한다)

- byte들의 연속 (OS는 파일 안의 데이터는 관심없고 byte들의 연속이라 생각한다!)

- 유저에 의해 하나의 단위(single entity)로 취급된다.

- 유일한 path name을 가진다.

- 접근 권한이 존재한다.

File system

파일과 관련된 서비스를 유저에게 제공하는 system software

File Naming

.c .gif .pdf .tex .txt .zip 등등의 파일 확장자를 설정할 수 있다.

File Structure

a: 바이트 순서로 나타낸 파일구조

b: 레코드 순서로 나타낸 파일구조

c: 트리로 나타낸 파일구조

File Types

OS는 실행파일을 제외하고 모든 파일의 내용은 신경쓰지 않는다.

- Text: 프로그램 실행 코드

- Data: 초기화된 데이터

File Attributes(속성)

- Protection: 접근 권한!!

- Record length: file size를 나타내며 항상 존재한다.

- Time of last access / change: 파일이 마지막으로 접근 혹은 변경된 시각

File Access Semantic(접근 방식)

Sequential Access
: 대부분의 파일 접근방식. 파일을 순차적으로 접근한다.
Direct(Random) Access: Method 1
- id = open(file)
- pread(id, &buf, from, rwbytes)
: 파일에 번호를 주고 어디서부터 몇 bytes를 버퍼에서 읽어달라고 요청하는 방식
Direct(Random) Access: Method 2
- id = open(file)
- lseek(id, SEET_SET, from)
- read(id, &buf, rwbytes)
: r/w pointer를 세팅하고(lseek), r/w하면 눈에보이지 않는 r/w pointer가 자동으로 증가하며 접근하는 방식

Method 2 방식을 프로세스 안에 쓰레드가 1개만 있을때 예전부터 사용해왔지만, 쓰레드가 여러개가 되면서 하나가 파일을 r/w하면 다른 쓰레드는 그 사실을 모르므로 Method 1방식의 pread가 도입되었다.

File Sharing Semantic

- 여러개의 process가 하나의 파일을 r/w하려 하려면 권한 허용이 필요하다! (아니면 lock이 필요하다)

- 파일을 write했을 때 다른 프로세스에 영향이 가는 시기
UNIX: 즉시 새로운 데이터 반영, Andrew File System(분산시스템, 서버 등): 파일이 closed된 이후에 반영

File Operations

files과 관련된 common system calls

Directory(Folder)

Hierarchical(계층적) Directory Systems

우: 계층적 directory구조. 아래의 파일이 위의 파일을 가리킬 수 없다. (Loop x)

File Name and Path Name

UNIX directory tree

Absolute path(절대경로)

- Root Directory에서 본 path. 절대경로의 path는 항상 unique해야한다!

Relative path(상대경로)

- 현재 작동중인 디렉토리에서부터 본 path

Directory Operations

directory들을 관리하는 System calls.

mkdir, link: 파일이름을 link라 본다.(파일 삭제시 unlink)

File System Layout

전체 Entire 하드디크스 block을 쭉 펴서 생각한다.

- MBR: Mast Boot Record, 이곳의 Boot code는 partition table을 보고 Boot Block으로 jump동작을 수행한다.

- disk partition을 4개로 쪼개서 사용하며 Superblock에는 전체 형상정보가 답겨있다.

- Free space mgmt(management)

File allocation methods

어떻게 파일에 할당된 데이터 블록을 관리할까?

- Contiguous allocation(연속적 할당)

: 파일 생성시 블록들이 연속적으로 할당된다.

- Chained allocation: non-contiguous allocation(불연속적)

: 다음 블록을 가리키는 pointer가 포함된 chain으로 block이 연결되어있다.

- Indexed allocation: non-contiguous allocation(불연속적)

: Index block이 파일의 data block list를 가진다.

Contiguous allocation

각 데이터 블록에 번호가 존재하며, block개수는 byte크기로 존재한다. 이 byte크기를 알면 block의 개수를 알 수 있다.

만약 File C를 요청하면 8번 block부터 8개의 block을 return한다.

- 만약 File A와 B가 삭제되어 각각 5개와 6개의 Free block이 생겼는데, 이 Free block에는 7개 이상의 block을 사용하는 File을 만들지 못한다는 단점이 있다. 보통 CD ROM에서 많이 사용되는 방식이다.

Linked List (Chained) allocation

File B를 읽으려면 1번 block부터 다음 블록번호인 8, 3, 14, 28번을 읽으면 끝난다. 만약 다음 블록번호가 -1이면 끝이라는 뜻이다.

이 방법은 block은 next block(meta data) + data(file data)이므로 2^n byte가 최적인 데이터가 아니며, 14번 block을 찾으려면 File B의 1번 block부터 3번 읽어야 하므로 바로 찾기(random access)가 불가능하므로 좋지 않은 방법이다.

physical block에는 다음 block번호가 적혀있으며 파일을 읽을때 이를 Link하여 읽을 수 있다.

Linked List (Chained) allocation Using a Table in Memory

next block pointer만 한곳에 모아 관리하도록 하는 방법

메모리에서 file allocation table을 사용한 chain allcation방법.

FAT(File Allocation Table)

파일을 찾을 때 FirstAddress 번호를 이용해 FAT blocks을 보며 찾는다.

이 방법은 보통 용량이 작고 호환성이 높은 디스크, USB drive에서 이 시스템을 사용한다. 용량이 커지면 FAT table의 크기가 커져서 사용하기 힘들기 때문이다.

Allocated block management - Indexed allocation

Index block(24번)에 데이터 block들의 번호가 적혀있다. File B를 찾을 때 24번 Index block에서 데이터를 읽으면 된다.

하지만 index block을 다 쓰면 하나 더 채용하거나 tree 형태로 만드는 등 해결책이 필요하다.

Design of Unix File System

- 위의 해결책으로 미리 고정된 위치에(한곳에) index block을 모아놓았고, 이를 UNIX에서는 I-node blocks라 부른다.

- i-node blocks의 0,1번 블록은 전통적으로 사용하지 않고, i-node에는 Data block번호와 파일의 다른속성까지 모두 기록되어있다.

- i-node에는 이름은 존재하지 않으며 이름은 directory에 존재한다!

UNIX Block Addressing

10개의 data block들이 존재하고 10개가 넘어가면 single, double, triple indirect block을 사용한다. single indirect는 512개의 datablock번호를 기록할 수 있고, double은 512^2, triple은 512^3개의 datablock번호를 기록할 수 있다.

Addressing방법은 나쁘지 않기 때문에 UNIX말고도 많이 사용하는 방법이다.

Directory Entry of FAT File System

파일이름 + 확장자(Extension): 8+3, 각 속성과 First block number, 파일의 size값이 존재한다.

Shared Files

shared file을 가지고있는 file system. shared file은 이름은 서로 다르지만 i-node는 동일하다.

link count=1이면 B 또는 C만 link, 2이면 B와 C 둘다 link. b의 경우 둘 다 원본(original)이며 구분이 없다.

Shared Files - Symbolic Link

Symbolic Link File (바로가기 파일, 별도의 파일임)

- 기존 shared file은 백업시 원본파일과 링크파일 모두 백업해야하는데, 원본이 삭제되었을 때 link는 삭제되지않고 그대로 남기때문에 무한루프 현상이 발생할 수 있다는 문제점있어 symbolic link file을 도입하였다.

- File Type을 Link File로 새로 정의한다.(special)

- 바로가기파일로 불리며, 파일의 path가 적혀있다.(pathname O)

- OS가 Link File을 읽으면 pathname을 통해 원본 파일을 읽을 수 있다. 따라서 부작용이 작다.

Log-Structured File System (LFS)

- 파일들이 고정된 위치에 존재하면 수정 또는 삭제시 파일 위치로 가서 동작하는데, 이는 HDD의 헤드가 왔다갔다 동작을 많이 해야하므로 성능이 떨어질 수 있다. 이에 log-structured file system을 도입하였다. (헤드가 있는 위치에서 파일을 옮겨다니면서 적자!)

- segment단위로 기록하며, 각 segment들은 i-nodes와 directory entry blocks, data blocks을 가진다.

- 이 시스템은 변경된 내용, write를 writing point부터 순차적으로 적는다.

Comparison between LFS and FFS

LFS는 순차적으로 변경된 내용들을 적는 반면, FFS(기존 UNIX 시스템)는 고정된 위치에 변경된 내용을 적는다.

LFS: Cleaning(Garbage Collection)

- 디스크 공간은 무한하지 않으므로 사용하지 않는 공간은 재사용하는것이 필요하다.

- Cleaner라는 background process를 통해 LFS는 log를 돌며 old segment들을 제거한다.

Obsolete blocks: 빈 공간, 3개의 segment에만 데이터가 존재한다.

: live block 데이터만 writing point(오른쪽 3개 segment 시작점)에 기록하면 통째로 앞 공간이 비게되어 이 공간을 나중에 다시 사용할 수 있다.

Journaling File Systems

UNIX에서 file을 제거하면 다음과 같은 경우가 발생한다.

file의 directory가 삭제된다
i-node를 free i-nodes(미사용)로 반납한다.
모든 disk block들을 free disk blocks으로 반납한다.

- 사용하다 전기가 나가면(shut down) 파일 시스템을 체크하여 consistant한 상태를 유지해야한다. (일관성 회복)

- 이는 동작시 log(기록)를 남기는 방법으로 처리하며, 파일 시스템 앞부분에 로그기록을 남길수 있는 부분이 존재한다.

-> 전기가 나가게되면 파일 시스템 전체를 다시 시작하는것이 아닌, 로그기록을 찾아서 필요한 부분만 다시 시작할 수 있다.

Journaling

: file system 구조가 변경되기 전에 Logging하는 방식이다. failure에대한 빠른 복구가 가능하며 NTFS, Linux Ext3 FS, Reiser FS등의 시스템이 존재한다.

Determining Block Size

Large block size

- 작은 사이즈를 넣지 못하므로 낭비되는 공간이 존재한다.

- 성능이 좋다.

- FAT의 entry수나 i-node의 block address list의 수가 적다.

Small block size

- space utilization이 좋다.(공간 사용도 높음)

- 성능이 떨어진다.

- FAT 또는 i-node의 수가 많다.

Disk Space Management Block Size

Disk 공간 활용도는 size가 작을수록 높고(4KB), 성능은 블록 크기가 클수록 커진다. 성능을 중시하는 서버는 8KB도 사용하지만 대부분 4KB를 사용한다.

Free space management

할당되지 않은 Free block을 관리하는 방법은 다음과 같다.

* Bit map (bit vector)

- 0이면 free block, 1이면 할당된 block을 나타낸다.

- contiguous free block들을 찾기 쉽다.

* Linked List

- 다음 freeblock이 어딘지 pointer로 적어둔다. 찾을때마다 읽어야하므로 효율이 떨어진다는 단점이 있다.

* Grouping (Indexing)

- index 블록에 여러개의 free block을 등록하는 방식이다.

Bit map

: free block을 bit map으로 관리하는 방법. 공간 차지를 덜하므로 가장 좋은 방법이다. Bitmap은 extra space를 필요로 한다.

EX)

- Block size = 2^12 bytes (4KB)

- Disk size = 2^30 bytes (1GB)

- N = 2^30 / 2^12 = 2^18 bytes (32KB), 32KB의 bitmap이 존재한다.

++ 연속적인 블록을 가져오기 쉽다!

Linked List

Free block list head는 기록되어있고, 이 헤드블록을 기준으로 linked된 다음 free block들을 읽으며 찾는다.

이 방법으로 free block을 할당하려면 block을 읽고 계속 찾아야하므로 성능이 떨어질 수 있다.

Linked List with Grouping (= indexing)

free block이 다른 free block에 대한 index block역할을 한다. index block list head로부터 다음 index block이 link되어있다.(linked list)

예전의 UNIX가 사용했으며 오래 사용하면 여기저기 흩어져있는 block이 많아지므로 성능이 떨어져 느려질 수 있다.

OS - 03. Memory Management

Eunbae — Tue, 28 Jun 2022 13:44:10 +0900

Address Space(주소 공간)

Physical address space: 실제 하드웨어가 지원하는 주소공간
Logical address space: 프로세스가 자신의 메모리를 바라보는 관점에서의 주소 공간 프로세스는 메모리를 가상 메모리 공간으로, 즉 본인의 실제 물리 메모리 공간보다 더 크다고 생각한다!

Address Generation

코드는 컴파일되어 어셈블리어로 번역된다. 이때 적재될 메모리 주소는 어디가 될지 모르므로 보통 0번지의 값을 가진다.

실제 메모리는 1000번지부터 적재되므로 jmp 175 코드는 실제 메모리의 175로 가면 안되고 1175로 가야 하므로 1175로 바꿔줘야 한다.

Multiple Programs Without Memory Abstraction

단일 프로그램은 하나씩 할당하여 충돌이 발생하지 않을 수 있지만, 여러 개 돌리면 메모리 공간 어디에 적재될지 모르므로 문제가 발생한다.

-> relocation이 필요하다!

Partioning

미리 메모리를 여러 개의 partition으로 쪼개 놓아 relocation이 필요 없도록 하는 방법이다.

Equal-size partitions (모든 파티션이 동일한 크기를 가짐)
Unequal-size partitions
: 파티션 별로 Queue가 존재한다.

: 처음부터 어느 파티션에 들어갈지 시작 주소를 다 알고 있다면 relocation은 필요하지 않다.

Placement with Partioning

물리 메모리는 고정된 크기의 파티션으로 나누어져 있다.

Internal fragmentation(내부 단편화 - 낭비되는 공간 O), Inefficient와 같은 문제점이 존재한다.

- 컴파일 시에는 항상 시작 주소를 0번지로 하고, 실행 시에 실행마다 주소를 바꾸어줄 필요가 있다. -> Dynamic Program Relocation!

Dynamic Program Relocation

CPU는 실시간으로 코드의 주소와 Limit register값을 비교하고 값보다 작다면 Base register의 값을 더해서 Relocate 한다!
(Logical Addresses -> Physical Addresses)

Dynamic Partitioning

파티션이 나누어져있을 때는 파티션마다 Q가 존재하였지만(a), 0번지를 기준으로 실행파일을 생성한다면 비어있는곳마다 실행하므로 노는 공간이 줄어들게 되고, 하나의 Q로 실행한다.(b)

-> 미리 쪼개지 말고 동적으로 파티셔닝 한다!

파티션은 가변크기의 길이와 숫자를 가진다.
프로세스는 메모리가 요구하는만큼 할당되어야 한다.
한 블록에서 모든 메모리를 순서대로 변환할 수 있도록 compaction을 사용해야 한다.??

동적 파티셔닝의 예시.

- 멀티프로세싱: 메모리에 여러 개의 프로세스를 넣고 실행하는 것

- a~d: 메모리 공간에 프로세스 1부터 3까지 적재된다.

- e: 프로세스 2가 입출력 요구 등을 이유로 잠깐 멈추면 메모리 공간에서 쫓아낸다.

- f: 빈 공간에 프로세스 4가 들어와 적재된다.

-> 다음과 같은 과정을 거치며 동적 파티셔닝이 일어나는데, 이때 중간중간 빈 공간(h)이 생기게 되어 메모리 효율이 떨어지게 된다.
이를 메모리 단편화, 즉 fragmentation이 일어난다고 한다.

Dynamic Partitioning Placment Algorithm

Best-fit Algorithm
First-fit Algorithm
Next-fit Algorithm
Worst-fit Algorithm

각 상황에 따라 좋은 알고리즘이 달라지므로, 각 알고리즘 중 어떤 알고리즘이 좋을지는 모른다. 케바케.

First-Fit: 항상 처음부터 살펴보다가 적재 가능한 곳이 있으면 발견한 처음 공간에 넣는다.

Best-Fit: 전체를 다 살펴보고, 가장 딱 들어맞는 크기의 공간에 넣는다.

Next-Fit: First-Fit과 유사. 한번 검색하면 마지막 검색위치를 기억하여 다음 검색 시에는 이 지점부터 찾기 시작한 후 발견한 공간에 넣는다.

Worst-Fit: 전체를 다 살펴보고, 가장 큰 공간에 넣는다.

-> 전체를 다 살펴보면 오래 걸리게 되고, 처음부터 찾아 바로 넣으면 윗부분의 메모리 사용도가 높아지며 빈 공간이 생길 수 있다는 단점이 존재한다.

모든 알고리즘은 장단점이 모두 존재하기 때문에 상황에 따라 달라진다!

Solutions for Fragmentation

Coalescing

Program A가 작업이 종료되면 빈공간이 생기는데, 이를 다른 빈 공간과 통합(Coalescing)하는 방법이다.

CPU는 2K와 5K를 통합하지 않는다면 각각 따로 생각하기 때문에 통합이 필요하다.

Compaction

메모리에서 사용되지 않는 공간(unused) 모두를 하나로 크게 통합하는 방법이다.

Compaction의 문제점

- optimal compaction 알고리즘을 찾기 어렵다.

- compaction 하는 동안 시스템은 정지한다.

Compaction을 수행하는 경우

- 메모리 utilization(효율)이 낮은 수치(75% 정도)로 떨어질 때

- memory allocation(할당) 실패 시

- 주기적으로

생각할때는 쉽게 동작하는 것처럼 보이지만 실제로 구현 시 어려움이 있다.

Swapping

기술이 발전하며 HDD의 속도가 빨라지게 되면서 메모리 사이즈보다 더 많은 프로세스를 넣고 실행하기 위해서 Swap In/Out개념을 도입하였다.

- 메모리에 프로세스를 많이 넣으면 넣을수록 CPU의 활용도. 즉 Utilization이 높아진다.

- c: 프로세스 A.B.C 모두 I/O요구 등의 이유로 중단된다면 이 중 하나인 A를 골라서 Swap out 한다; 프로세스의 메모리 데이터 그대로 - HDD의 swap영역에 넣고 프로세스를 쫓아낸다.

- 이렇게 Swap in/out을 하면 더 많은 프로세스를 사용할 수 있고 Utilization이 높아진다.

- 현재도 Swap을 사용하는데, CPU Utiilization을 높이려기보다는 threashing 현상으로 시스템이 다운되는 것을 방지하기 위해 사용한다.

+) 프로그램 수행 이미지의 크기가 변하는 경우. 사용 가능한 메모리 공간보다 더 커지게 되면 swapping으로 잠시 디스크로 옮기고 큰 공간이 나오게 된다면 그때 수행된다.

Overlay

램보다 프로그램 크기가 클 때 수행하는 방법. Overlay기능을 켜고 작업을 수행할 수 있다.

Program 실행 시 함수 별로 모듈을 생성한다.
프로그램에 작성되어 있는 오버레이 매니저 코드가 실행된다.
A를 수행하다 B함수가 호출(call)되면
매니저가 확인 후에 A를 쫓아내고 B를 실행한다.(overlay)

Memory Management with Bitmaps

a: 메모리 공간. A~E까지 5개의 프로세스가 적재되어있고, 3개의 비어있는 공간이 존재한다.

b: bitmap. 1이면 사용 중이고 0이면 비어있음을 나타낸다.

c: b를 linked-list로 표현한 방식. P면 사용 중, H면 비어있음을 나타내고 H 5 3이면 5번부터 3개의 상태가 비어있음을 나타낸다.

Virtual Memory

- CPU는 메모리를 공간이 무한한 Logical Memory로 인식한다; 가상 주소와 실제 주소를 분리하여 생각한다.

- 가상 주소 공간에서 프로그램을 실행하고 이는 실제 DRAM에 적재되며, 실제 주소로 변환하여 실행하도록 한다.

Virtual Address Space

: 모든 프로세스는 위 가상공간 모두를 혼자 다 쓴다는 환상을 가지고 실행한다.

- 이 개념을 통해 작은 DRAM보다 size가 더 큰 프로세스를 넣고 실행할 수도 있다. 이는 필요 부분만 DRAM에 적재하고 나머지는 DISK에서 Swap 하여 실행한다.

Paging(Virtual memory) 기법

- Virtual Address Space을 동일한 크기인 Page단위로 쪼갠다.

- Virtual Address(VA): 20bit는 페이지 번호로, 12bit는 페이지 안의 offset으로 쪼개어 할당한다. (p, o)

- Physical Memory는 동일한 크기인 Frame단위로 쪼갠다.

- Physical Address도 마찬가지로 프레임 번호와 offset으로 쪼개어 할당한다. (f, o)

- (f, o) = (3, 6)이면 3번째 frame의 6번째 offset을 나타낸다.

Page는 frame으로 매핑된다. page의 일부는 DRAM으로, 일부는 Disk의 Swap영역에 적재된다.

가상공간을 페이지 단위로 쪼개어 특정 프레임에 넣고 실행하겠다는 것이 페이징 처리이다.

Virtual Address Translation

(p, o) 페이지가 (f, o) 프레임에 적재될 때 가상 주소는 물리 주소로 실시간으로 변환되어 access 하도록 구현되어야 한다.

이는 CPU 내부의 Page Table을 통해 수행되는데, 과정은 다음과 같다.

(p, o) 가상 주소가 나오면
Page Table의 p번째 엔트리를 찾는다.
찾아보니 f가 적혀있기 때문에
(f, o)을 Access 한다.

Page Table Structure

Page Table의 contents

- Flags : valid/invalid(resident) bit, dirty bit, reference(clock or used) bit

- page frame number

- PTBR(Page Table Base Register)이 Page Table을 가리키게 한다.

- Flag 중 valid bit가 1이면 frame을 access 하고, 0이면 CPU가 스스로 해결하지 못하므로 page interrupt를 걸어 jump 한다. (OS가 swap영역에서 PT에 세팅하여 1로 변환해준다)

- valid bit: 메인 메모리에 해당 페이지가 존재하는가?

- Page Table은 2^20개의 페이지(1MB)가 존재하며 한 entry의 크기는 4kb이므로 프로세스마다 4MB의 Page Table이 필요하다.

Translation Lookaside Buffer(TLB - 명칭 외우기!!)

가상 메모리는 PT entry 접근 1번, 물리 주소 접근 1번 총 2번의 접근이 필요하기 때문에(물리 메모리 : 1번만 접근) 메모리 효율이 2배로 떨어진다는 문제점이 있다.

이를 해결하기 위해 CPU의 Cache와 같은 기능을 가지는 Translation Lookaside Buffer(TLB)를 도입하였다.

- 최근에 Access 한 PT entry만 caching 하고 있자!

동작 과정 - CPU 내부 회로에서 실시간으로 동작한다.

가상 주소 변환 시 우선 TLB에서 엔트리를 찾는다.
TLB에 없다면 PT에 접근(Access)하여 찾는다.
PT에서 찾았다면(접근했다면) TLB에 넣는다.

문맥 교환 시 Valid bit의 초기 상태는 모두 0이다.(Invalid)
TLB에서 못 찾으면 PT를 거쳐서 변환한다
한번 Access 하면 TLB에 적고, valid bit를 1로 바꾼다.
Page Table의 valid bit: 1일 때는 존재한다는 것이고, 0일 때는 Disk의 swap영역에 존재한다는 뜻이다.

문맥 교환 시 TLB의 Valid bit는 0으로 CLEAR 된다. 이는 TLB히트율이 잠시 떨어진다 할 수 있다. (물론 TLB가 다시 채워지면 높아진다)

Protection and Sharing

Process A, B의 데이터 Page Table은 서로 다르지만 내부 코드 부분의 f=4는 동일하다. f=4에 해당하는 프레임은 메모리에 따로 적재하지 않고 똑같은 프레임을 가리키게 하는데, 이를 Sharing 한다고 한다.

하지만 이는 Read-only모드일 때는 가능하지만, Write 명령이라면 OS에 부탁하여 물리 메모리를 copy 하여 두 개의 영역에서 write 하도록 한다.

++ OS는 각 프로세스마다 Page Table 을 유지하도록 한다.

Page Table

Assignment of Process Pages to Free Frames

- A process의 0번 페이지, 1번페이지, ... , B process의 0번 페이지, ...를 메모리에 적재한다.

- 각 프로세스는 적재될 때 빈 프레임이면 어디든 적재될 수 있다. (process D-꼭 연속적으로 적재될 필요는 없다!)

- Process B가 수행 종료되었으므로 PT의 valid bit는 모두 0(N)으로 된다.

- 프로세스를 페이지 별로 나누어 메모리에 적재하므로 메모리 단편화(Fragmentation)가 일어나지 않는다! (페이지 내에서 사용되지 않는 공간은 존재할 수는 있다.)

Logical-to-Physical Address Translation of Paging. CPU 내부의 하드웨어 회로에 의해 빠르게 진행된다.

Virtual Memory - Paging

CPU에서 가상주소는 MMU chip(변환회로)을 통해 가상주소를 물리주소로 바꾸어 Bus를 통해 메모리에 할당한다.

만약 페이지번호: 0010 -> 2이라면 PT에서 2번째 엔트리를 찾아 110으로 주소를 변환한다.(valid: 1) 12-bit offset은 직접적으로 copy된다.

Structure of Page Table Entry

Caching disabled: 0이면 caching, 해당 bit를 보고 CPU에 캐시할지말지를 결정한다.
Referenced: 주소 변환할때마다 1로세팅한다. - CPU 교체정책에서 사용된다. 후술.
Modified(dirty): 해당 페이지가 메인 메모리 프레임에 적재된 이후 변경되었다는것을 표시해준다.
Protection: read/write/execution의 보호기능을 한다. 운영체제가 이를 점검하여 보안관련 기능이 수행될수있다.
Present/absent(valid): 메인 메모리에 해당 패이지가 존재하는지 여부를 보여준다.
Page frame number

Speeding Up Paging

가상주소에서 물리주소로 매핑되는 과정은 빨라야 한다.
가상주소공간이 크면 클수록 Page Table의 크기도 커져야한다.

-> TLB를 사용하더라도 Page Table이 너무 크다면 PT는 메모리의 상당부분을 차지한다.

Translation Lookaside Buffers

- Page Table에서 주소를 변환하면 TLB에 적재된 후 Valid bit는 1로 바뀐다.

- TLB는 최근에 주소변환한 내용만 기억한다!

- TLB에 64, 128개 정도의 페이지만 존재하더라도(적은 페이지수) 히트율은 크게 증가한다.

Problem: Too Large Page Table solution

- Multilevel paging

- Inverted page table

Multilevel paging

singlelevel page는 2^20개의 entry가 모두 존재해야한다.

PT를 Multilevel로 구현하면 Top-level Page Table에만 entry가 존재하면 되므로 2nd PT부터는 entry가 존재하지 않아도 된다.

페이지번호에는 p1, p2의 여러 단계의 페이지 테이블 번호가 적혀있다.

이 방법을 사용하면 3번 Access하므로 TLB Miss가 발생하면 많은 메모리를 사용해야하므로 접근율이 떨어질 수 있다는 단점이 존재한다.

Inverted page table(역페이지 테이블)

- Page Table에 페이지 번호(몇번 프로세스에 몇번 페이지가 있는지)가 기록되어있고, 전체 시스템에 하나만 존재한다. (프로세스마다 존재 x)

Process Id(Pid)를 통해 PT의 entry를 찾는다.
i번째 프레임에 프로세스가 존재한다는 사실을 안다
이 i가 물리주소가 되어 변환해준다.

또한 TLB도 존재하며, 발상의 전환이라 할 수 있다!

- PT의 메모리 공간이 줄어든다는 장점이 있지만, TLB Miss가 나게되면 하드웨어 회로 말고 소프트웨어가 검색(해쉬 탐색등)하여 TLB를 세팅한 후 동작해야한다는 문제점이 존재한다. 이에 현재는 잘 사용하지 않는 방식이다.

Address Space and OS

- 모든 Process는 각각의 OS 코드 데이터가 Mapping되어있다.

- 각 Process가 main, I/O등을 실행하는 코드 실행시 Interrupt service routine을 이 OS 코드 데이터로 자기가 직접 실행한다!

- Shared Library: paging 기법을 이용해서 Library를 공유할 수 있다.

코드를 미리 적재하지 않고 필요한 페이지가 참조될 때 page fault형태로 핸들링하면서 적재하겠다는 demand paging방법을 요즘 대부분 사용한다!

Page Faults

- mapping되지 않은 페이지가 참조되면 page fault가 발생한다.

- 만약 hwp실행파일을 실행했다고 하자. 우선 disk의 swap영역에 수행 이미지를 만들고, 메인 함수를 CPU에서 실행한다. 이때 PT를 보면 valid 비트는 모두 0이다. 메모리의 프레임이 할당되어있지 않은것이다. 따라서 주소변환하지 못하므로 CPU는 할 작업이 없으므로 스스로 interrupt를 건다. OS의 fault handler는 이를 보고 정해진 서비스루틴으로 jump한다. OS의 fault handler는 적재가 안되서 나오는 page fault인지 확인한 후 맞다면 해당 페이지를 swap영역이나 실행파일에서 찾아서 읽고 메인 메모리의 빈 frame에 넣은 후 Page Table의 valid bit를 1로 변환한 후 적재한다.

- 빈 프레임이 없다면(메모리가 꽉 찼다면) 기존 적재된 프레임 중 하나를 쫓아내야한다. -> Replacement 정책!

!! page fault가 발생할 확률은 매우 작아야한다!

만약 또 참조될 프로세스를 쫓아내면 또다시 가져와야한다. 이러한 page fault가 나오면 어마어마한 시간을 손해보기 떄문에 쫓아낼 때 잘 쫓아내는 것이 중요하다!

Page Replacement Algorithms

프레임에 새로운 페이지를 넣으려면 기존 메모리에 적재된 페이지를 쫓아내야한다.

-> 기존 프레임에 적재된 페이지 중 어느것을 쫓아내고 새로운 페이지를 넣을까?

Optimal page replacement algorithm
- 미래를 알고있다는 전제하에 사용하므로 실제 사용할 수 없지만 다른 방법과 성능을 비교할 때 쓰인다.
Not recently used(NRU) page replacement
First-In, First-Out page replacement
Second chance page replacement
Clock page replacement
Least recently used(LRU) page replacement
Working set page replacement
WSClock page replacement

NRU(Not Recently Used), FIFO

NRU: 최근에 참조되지 않은 페이지를 쫓아내겠다!

Class 0: Not Referenced, Not Modified
Class 1: Not Referenced, Modified
Class 2: Referenced, Not Modified
Class 3: Referenced, Modified

-> Class 0의 페이지를 우선해서 쫓아내고, 만약 없다면 그 다음 Class 1, 2, 3순서로 쫓아낸다.

- reference bit를 확인하여 1로 세팅되어있다면 최근에 참조(주소변환)되었으므로 우선순위가 낮다.

- modified: 변경(write 등)안되어있다면 바로 쫓아내고, 변경되었다면 해당페이지를 쫓아내기 전에 swap영역에 다시 적어야한다.

- NRU 기법은 실제로 많이 변형해서 사용하는 기법이다.

FIFO: 선입선출, 가장 먼저 적재되었다고해서 참조가 덜 되는것은 아니기 떄문에 참조가 많이 되는 페이지(hot page)를 쫓아낼 수 있다는 단점이 있다. (성능에 손해를 볼 수 있다)

Second Chance Algorithm

FIFO를 보완한 알고리즘. 가장 먼저 들어온 페이지의 참조비트가 1이라면 0으로 변경하고 가장 마지막으로 보낸다.(한번 더 기회를 더 줌)

The Clock Page Replacement Algorithm

메모리에 적재된 페이지들 사이에서 Clock hand가

돌아가며 가리키는 페이지부터 확인한다.
만약 검사하는 페이지의 reference bit가 1이면 넘어가고 0이면 쫓아낸다.

LRU Page Replacement Algorithm

Top: Most Recently Used (MRU) Page

Bottom: Least Recently Used (LRU) page

항상 LRU page를 교체한다.(쫓아낸다)

참조될때마다 페이지 순서가 LRU page stack에 linked-list로 만든다. 이는 소프트웨어적으로 구현이 쉽지만 하드웨어인 CPU 캐시에 구현하기는 어렵다.

-> 현재 가장 연구가 많이되어있고 성능이 좋은 알고리즘이며 모든 프로그램이 가장 많이 사용하는 방식이다.

- 페이지 참조 bit를 행렬로 만들어서 관리하는 방법이 있다. 0번 페이지 참조시 행은 모두 1로, 열은 모두 0으로 만들고 확인시 행으로 가서 가장 큰값을 가지는 페이지가 최근에 참조된것이고, 가장 작은값을 가지는 페이지는 예전에 참조된 것이다. 최근에 몇번 참조되었는지 확인할 수 없다.

이 방법도 페이지수가 많아지게 되면 CPU가 해주기에는 큰 일이다.

또다른 LRU 관리 방법)

- CPU는 참조(주소변환)될때마다 R bit를 1로 세팅한다.

- CPU Clock이 한번 tick할때마다 6개 페이지의 R bit를 가장 왼쪽에 각각 기록한다.

- 최근 참조된 bit는 가장 클것이고, 가장 옛날에 참조된 bit는 가장 작을것이다. 또한 최근에 참조된 횟수도 표현이 가능하다!

-> 하지만 페이지 개수가 많아지면 카운트를 유지하기 어려워지기 때문에 실제 시스템 구현시엔 어렵다.

Comparison of OPT, LRU, FIFO, CLOCK

OPT에서 3번의 Fault가 나오므로 3번보다 더 줄일 수 있는 알고리즘은 존재하지 않는다.

Working Set Page Replacement

- Working Set: 작업 집합. 프로그램이 실행하는데 필요한 페이지들

- Working Set이 메모리에 올라오면 잘 작동하고, 없다면 가져와야한다.

- R(Referenced bit)==1이면 놔두고 R==0이면 working set에 속하는지 확인한다.

- R==0이면서 age(현재 시간 - 마지막 사용시간) > τ이면 페이지를 제거한다.

WSClock Page Replacemnet Algorithm

Working Set에 속한 Page들은 꼭 필요하므로 그것들은 메모리에 가지고 있겠다는 것. 특히 멀티프로그래밍에서 기본이 되는 이론이다.

Clock Page 알고리즘에 Working Set 개념을 추가한 방식이다.

ex. R bit가 1이면 0으로 바꾸고 clock hand를 움직인다. 만약 R bit가 0이면 페이지를 교체한다.

Summary of Page Replacement Algorithms

LRU Algorithm은 다른 기법의 기본이 되는 알고리즘이다. 하지만 하드웨어적으로 구현이 어려워 Working set..등으로 보완했지만 실질적으로 많은 CPU는 NRU를 응용한 Two handed Clock기법을 사용한다!

Thrashing

: 메모리에 너무 많은 process가 적재되어있어서 각 프로세스의 working set이 적재될 수 없는 현상. swapping으로 이를 해결할 수 있다.

OS - 02. Processes and Threads (2)

Eunbae — Mon, 13 Jun 2022 03:51:56 +0900

Scheduling

다음에 실행할 프로세스 또는 쓰레드를 선택하는 과정

스케줄링 시점

프로세스가 생성될 때
프로세스가 종료할 때
프로세스가 I/O, Semaphore, 또는 다른 무언가로 대기할 때
I/O interrupt가 발생할 때
선점 스케줄링 알고리즘(preemptive scheduling)의 경우 Clock Interrupt가 발생할 때

스케줄링 오버헤드(문맥교환비용)

모드 변경 비용(사용자 > 커널 > 사용자)
프로세스 문맥 저장, 복구
메모리 맵 저장, 복구
CPU 캐시 무효화
기타

Process Behavior - 프로세스의 실행 형태

CPU-bound process : 한번실행하면 I/O요청 거의없이 계속 계산만 하는 프로세스.
I/O-bound process : 잠깐 계산하고 I/O를 요구하는 프로세스. 대부분의 프로그램이 이에 해당한다.(word, chrome, exel, ...)

a: CPU-bound process, b: I/O-bound process

프로세스의 우선순위는 CPU-bound < I/O-bound이다! (자원의 활용도를 높이기 위함)

Type of Scheduling

Long-term scheduling : 사용자가 요구할 때, 즉 프로세스 실행시 바로 실행할지 delay해서 실행할지 등을 결정한다.
Medium-term scheduling : 현재 실행중인 프로세스가 많을 때(threashing) suspend상태로 변경한다.
Short-term scheduling : 굉장히 자주 실행되며, 어떤 프로세스를 실행할지 짧은 시간안에 결정한다.
I/O scheduling : 5장에서..

Queing for Scheduling

Long-term scheduling으로 실행 할 프로세스를 필요한 자원(process Id 등)을 세팅한 다음 Ready Queue에 하나씩 할당한다.

이후 프로세스 실행 과정에서 입출력 요구시 프로세스를 block상태로 만들고 Blocked Queue에 할당한다. Block상태 프로세스는 suspend상태나 ready상태가 될 수 있다.

만약 시스템의 메모리 부족 등을 이유로 Medium-term scheduling이 block, ready중인 프로세스 몇개를 suspend상태로 변경할 수 있다.

Categories of Scheduling Algorithms

Batch - 하나씩 가져가며 쭉 실행
Interactive - 번갈아가며 실행
Real time - 실시간으로 실행. 정해지 시간 내에 응답해야함

각 알고리즘의 주요 목표

Batch: Throughput(시간당 몇개의 작업을 끝냈는가), Turnaround time(작업이 시작하고 끝날때까지 걸리는시간), CPU utilization이 높아야한다.
Interactive: Response time이 높아야한다.
Real-time: 데드라인을 만족하고, 예측가능해야한다.

Scheduling in Batch Systems

First-come first-served
Shortest job first
Shortest remaining time next

First-come first-served

프로세스를 온 순서대로 실행한다. 실행시간이 작은 E의 waiting time이 높다.

Shortest job first

Time:8일때 도착한 프로세스는 C, D, E이기 때문에 가장 수행시간이 짧은 E 먼저 수행된다.

프로세스가 종료될 때 남은 프로세스 중 실행시간이 가장 짧은 프로세스부터 수행한다.

Shortest remaining time next

Time:4일 때 B의 남은 작업시간은 5이고, C의 작업시간은 4이므로 C가먼저 실행된다.

Shortest Job First의 선점(Preemptive)한 스케줄링. 실행하던 작업을 중단한 후에 실행한다.

하지만 긴 작업은 계속 밀려서 서비스가 안되는 starvation이 발생할 수 있다.

Highest Response Ratio Next(HRRN)

프로세스별로 비율을 계산(오른쪽그림)하여 계산 값이 가장 큰 프로세스가 먼저 수행된다. 앞선 알고리즘의 starvation문제를 해결할 수 있다.

Scheduling in Interactive Systems

Round-robin scheduling
Priority scheduling
Multiple queues
Shortest process next
Guaranteed scheduling
Lottery scheduling
Fair-share scheduling

Round-robin Scheduling

프로세스가 같은 우선순위일때, 번갈아가며 실행하는 스케줄링 방법. B는 실행되다 자신의 quantum을 다 쓰면 뒤로간다.

a: time quantum이 프로세스 종료시간보다 클 경우, b: time quantum이 프로세스 종료시간보다 짧을 경우(프로세스 종료 전에 문맥교환이 일어나는 경우)

- 프로세스는 자신의 time quantum을 다 사용하기 전에 I/O등을 요구하면 비효율적이다. 그래서 자신의 time quantum을 다 소비하기 전까지는 Ready Queue에 들어가지 않고 Auxiliary Queue에 들어간다. 이후 time quantum을 다 소비한다면 Ready Queue에 들어간다. (우선순위: Ready Queue < Auxiliary Queue) 이를 Virtual Round-Robin방식이라 한다.

Virtual Round-Robin

Priority Scheduling

프로세스마다 우선순위를 가진다. 우선순위가 클수록 숫자가 높고, 낮을수록 숫자가 작다.

이때 동일한 우선순위를 가지는 프로세스는 Round-robin방식을 사용하고, 동일한 우선순위의 프로세스를 다 수행하면 다음 우선순위의 프로세스를 수행한다.

Multilevel Feedback Queue (Multi Queue)

우선순위가 CPU-bound process < I/O-bound process이도록 하는 스케줄링 방법이다.
RQ(Ready Queue)0은 우선순위가 가장 높고 RQn은 우선순위가 가장 낮다.
RQ0에서 프로세스를 하나씩 가져와 처리하는데, 만약 CPU-bound process이면 다음 우선순위 큐로 넣는다.
RQ0을 다 쓰면 RQ1에서 동작하는데, 이때도 CPU-bound이면 다음우선순위 큐로간다
이 과정을 거치면 CPU-bound process는 가장 낮은 우선순위의 Ready Queue로 가게되고 이를 우선순위가 낮아진다고 표현한다.

Feedback Scheduling

Shrot Process Next

예상 실행시간이 가장 짧은 프로세스를 먼저 실행하는 스케줄링 방법이다.

실행시간이 짧은 프로세스는 실행시간이 더 긴 프로세스를 뛰어넘어 먼저 실행한다.

예상 실행시간은 오른쪽의 식과같이 구하고, 이는 과거에 실행했던 실행시간의 평균을 보고 계산하는 방법이다. 식은 마지막 실행시간(Tn)과 그 전의 실행시간의 합(Sn)과 가중치(a)를 곱하는데, 이는 특정 작업이 평균시간보다 더 많이 걸리게 되면 평균이 높아질 수 있지만 식과 같이 계산하면서 변화되는 패턴에 빠르게 대응할 수 있다.

Exponetial Smoothing Coefficients

Guaranteed Scheduling

프로세스마다 CPU시간을 1/n씩 할당하여 실행하도록 보장해주는 스케줄링 방법이다. 이는 리눅스의 Fair Share Scheduling(다다음)에서 쓰인다.

Lottery Scheduling

n값이 랜덤일 때 각 프로세스마다 n%의 실행시간을 가지도록 하는 스케줄링 방법이다. 이때 시행비율을 임의로 조절 가능하다.

Fair-share Scheduling

프로세스마다 "공평한 몫"의 시간을 사용하도록 하는 스케줄링 방법이다.

CPU(i)값과 G(Group)CPU(i)값은 프로세스마다 1/2씩 decay된다.

P(i)값이 가장 작은 프로세스부터 실행되며 GCPU(i)값은 4*Wk(그룹마다 주는 가중치)로 나누어 더한다. 이는 한 프로그램이 프로세스를 여러개(n개)를 사용하면 CPU사용시간이 n배가 되므로 공평하지 않기 때문이다.

Fair-share Scheduling의 예시

프로세스가 실행되면 프로세스의 CPU count가 증가한다.
한 period가 지나면, 각 CPU count에 1/2를 곱한다.
이때 decay로 1/2씩 곱한다.
이후 값이 가장 작은 프로세스를 실행하고, 1번 과정부터 4번과정까지 반복된다.
실행을 안하고 기다리게되면 decay로 우선순위가 다시 높아지게된다. 이는 계속 우선순위가 밀려 실행되지 않는 경우를 방지하고, aging기능이라 할 수 있다.

Scheduling Mechanism vs Policy

scheduling mechanism과 scheduling policy를 구분해야한다.
커널은 스케줄링 메커니즘을 가지고 있어야한다.
커널 알고리즘 또는 유저 프로세스는 scheduling policy를 결정해야한다. (FIFO, RealTime등의 메커니즘을 갖고있다가 지정하면 policy를 집행할 수 있어야 한다.)

Thread Scheduling

a: user-level threads를 스케줄링하는 방법. 커널은 프로세스 2개가 있다고 생각하며 A, B만 번갈아가며 실행하고 있다고 생각한다. 프로세스마다 미니 커널이 있어서 이 미니커널이 알아서 쓰레드를 조작한다.

b: kerner-level threads를 스케줄링하는 방법. 커널이 처음부터 쓰레드를 조작한다.

- 현재는 a의 유저레벨 쓰레드는 생각할 필요가 없다.

Traditional Unix Scheduling

각 priority queue들을 갖고있는 Round-robin방식을 이용해 Multilevel feedback을 사용한다.

한번 동작하면 우선순위가 낮아지고, 실행을 안하고 기다리고 있으면 우선순위가 다시 올라가는 방식이다.

매번 우선순위를 다시 계산하여 Pj(i)값이 작을수록 우선순위가 높다.

- 프로세스의 우선순위를 낮추는 경우는 다음과 같다.

Swapper
Block I/O device control
File manipulation
Character I/O device control
User processes

- Unix Scheduling은 프로세스별로 특정 밴드(Bands)에 소속되어서 실행하도록 한다. 만약 입출력이 끝나면(깨어나면) 우선순위가 높은 밴드로 가게하여 빨리 처리하도록 한다!

Traditional Unix Scheduling 예시

BSD and SVR3 scheduling

- 프로세스가 실행되는 동안 p_cpu의 값은 증가하게된다.(clock tick increments)

- 매 초마다 모든 프로세스의 우선순위는 재계산된다.

SVR3: 프로세스가 많아질수록 1/2 decay는 과하게 되어서 결국 대부분의 프로세스가 0이 되어서 구별할 수 없게된다.
BSD: decay = (2*load_avg) / (2*load_avg + 1)의 식으로 동작하여 실행중인 프로세스의 개수에 따라 값이 정해지도록 한다.

Scheduling Examples

Linux Scheduling
Unix Scheduling
Windows Scheduling

Linux Scheduling

O(1): Linux SCHED_OTHER Scheduling

I/O-bound process에게 높은 우선순위를 주는 정책이다.
태스크(task, 리눅스에서 thread를 부르는 용어)의 실행시간 대비 휴먼시간 비율(sleep_avg)을 유지한다.
우선순위와 타임슬라이스 계산식
effective prio = 인터액티브 정도 + 정적 우선순위
새로운 타임슬라이스 = effective prio에 비례함
인터액티브 태스크는 expired Q가 아닌 active Q에 넣어 또 실행할 수 있도록 한다.
(원래 태스크의 time slice를 다 소비하면 expired Q에 넣는다)

문제점

Nice값이 timeslice의 절대값을 결정한다.
Nice값의 차이가 timeslice 차이에 비례하지 않는다.
Timeslice와 timertick의 granularity(정밀도)문제가 있다.
Interactive task의 우선 문제가 있다.
- sleep에서 깨어나면 무조건 active Q로 들어온다.

CFS 스케줄러

앞선 O(1)의 문제점을 보완하고 개선한 RSDL을 개발하였다.

I/O-bound와 CPU-bound process의 구분을 없애고 CPU할당시간을 공평하게 분배하였다.
Run Q를 없애고 RB-tree를 사용하였다.
Jiffies와 HZ상수를 이용하지 않고 나노초단위로 동작하게(정확히 집행하도록) 하였다.
통계적 기법이나 휴리스틱을 이용하지 않았다.

Virtual Runtime

: Time slice와 timertick의 granularity문제를 해결한다.

-> 문맥교환(time slice) 주기가 20ms. 두 태스크가 45ms, 15ms비율로 수행해야하면 실제로는 40ms, 20ms씩 수행한다.

이 수행시간 40ms, 20ms에 scale factor(1:3)을 곱하여 virtual runtime을 구하는데, 40ms, 60ms로 같지 않다면 뒤쳐진 태스크(40ms)를 수행하여(-> 20ms더 수행하면 60ms, 60ms) 시간을 보상한다.

따라서 CFS의 목표는 모든 Virtual Runtime을 균등하도록 하는 것이다!

Unix SVR4 Scheduling

- 160개의 우선순위를 가진 스케줄링 Queue를 가진다.

- Preemption point를 넣어 작동하도록 한다.

Preemption point: 만약 시스템 호출하여 데이터를 리턴하기 전에 스케줄링한다면 시스템호출+스케줄링의 시간이 많이 길어질 수 있다.

이를 방지하기위해 커널에 preemption point, 즉 스케줄이 되는 지점을 몇개 넣어서 시스템 호출이 되더라도 이 point에 도달하면 급하게 작업할 프로세스(RealTime 등)가 있다면 바로 스케줄하여 작업을 실행하도록 한다.

Windows Scheduling

우선순위는 두가지의 band 혹은 class로 나뉜다. - Real time 또는 Variable(Non-Real time)
우선순위기반 preemptive scheduler을 사용한다.

Real-time: 31~16, Variable(일반 프로그램): 15~0값과 각각의 Queue를 가진다.

15~0의 일반 프로그램은 한번 동작하면 우선순위가 낮아지고, 실행을 안하고 기다리고 있으면 우선순위가 다시 올라가는 방식을 사용하여 동적으로 할당된다.

Dining Philosophers Problem

식사하는 철학자 문제. 데드락의 동기화 문제를 설명한다.

철학자가 식사하려면 양쪽의 모든 포크를 집어야하고, 어떤 경우는 철학자 모두 식사를 못하고 계속 굶어 죽을 수 있다.

OS - 02. Processes and Threads (1)

Eunbae — Tue, 7 Jun 2022 16:46:50 +0900

Race Conditions

- ProcessA와 B가 동시에 공유 메모리를 access(접근)하기 원하는 상태. 경쟁상황이 발생할 수 있고, 경쟁 결과에 따라 결과값이 변경될 수 있다.

Critical Regions

race condition을 피하기 위한 필요 조건

Mutual Exclusion : 상호배제, 동시에 임계구역에 들어갈 수 없도록한다.
Progress : 임계 영역 밖에서 실행되는 어떠한 프로세스도 다른 프로세스를 차단할 수 없다.
Bounded Waiting : 임계 영역에 들어가기 위해 영원히 기다리는 프로세스는 없도록 한다.

process A가 임계구역에 들어가면 B는 A가 나올때까지 기다린다.

상호배제(Mutual Exclusion)를 구현하기 위한 제안

Disabling interrupts
Lock variables
Strict alternation
peterson's solution
The TSL instruction

Strict Alternation

process j가 임계 영역에 들어갈때까지 process i는 계속 대기 상태가 되어 실행되지 않는다. 제대로된 해결책이 아님!

Dekker's Solution

Process i는 상대방 flag를 보고 j가 TRUE면 while문에서 기다린다. FALSE이면 turn이 j인지 확인하고, j라면 자신의 flag를 FALSE로 만들고 turn이 i가 될때까지 기다린다. turn이 i이면 그때 임계구역에 들어갈 수 있다.

- flag: 들어가겠다는 표지

- turn: 실제 배정받은 turn(실행중 표시)

Peterson's Solution

Dekker와 비슷하지만 여기서 turn의 의미는 양보할 프로세스이다. Process i는 flag가 i, turn이 j일때까지 기다렸다가 임계구역에 들어간다.

Bakery Algorithm

프로세스(쓰레드)의 개수가 n개일때, 빵집처럼 번호표를 받아서 번호표가 같을 때 고유 id 순으로 임계 영역에 들어간다.

The TSL Instruction

위 빵집알고리즘은 소프트웨어적 도구인데, 이를 수행하기에는 너무 heavy함으로 하드웨어의 도움이 필요하다. 이에 TSL Register를 도입하여 하드웨어적으로 작성한다. (TSL = Test and Set Lock)

좌: TSL Instruction, 우: XCHG Instruction

TSL은 Lock 변수를 register로 가져와서 1로 세팅한다. 세팅 이전의 Lock값이 0인지 확인 한 후, 0이라면 return하여 임계구역에 진입하고 1이라면 다른 process가 이미 1로 세팅하여 사용중이므로 loop를 돌며 확인한다.

XCHG는 Lock변수와 Register를 exchange(swap)하여 TSL과 같은 과정을 거친다.

The Producer-Consumer Problem

Producer-Consumer관계의 두 프로세스는 둘 다 Sleep할 수 있는 치명적인 race condition을 가질 수 있다.
producer는 item을 만들어서 queue에 넣고, count가 N에 도달(queue가 꽉 참)하면 스스로 sleep한다. 이를 consumer가 count가 N-1이 될 때(꽉 차지 않게됨)를 확인 후 producer를 깨워주는 방식으로 동작한다.
producer의 sleep직전에 cousumer가 실행되어 wakeup하게되면 producer는 sleep상태를 유지하게되고 이후 cousumer는 큐를 모두 소비하고 sleep하게되므로 결국 둘 다 sleep하게되는 문제가 발생한다. 이는 반대의 경우(consumer의 sleep직전에 producer가 실행되어 wakeup)도 마찬가지로 문제가 발생한다.

Semaphores

Semaphore는 Up&Down연산자를 사용하고, mutual exclusion(상호배제)와 synchronization(동기화)를 위해 사용될 수 있다.

down은 count를 감소시키고 만약 카운트가 0보다 작다면 (즉, sleep조건이면) down을 호출한 프로세스를 sleep시킨다.

up도 down과 마찬가지로 count를 증가시키고 만약 카운트가 0보다 같거나 작다면 sleep중인 프로세스를 wake up시켜준다.

각 down과 up과정은 수행중 끼어들 수 없고, 이를 아토믹하게(원자적으로) 진행한다고 한다.

producer-cousumer problem을 Semaphore로 해결한 과정

Producer과 Consumer사이에는 유한한 큐 버퍼가 존재하고, Semaphore n, mutex, e를 설정한다.

down(mutex)를 producer와 consumer가 동시에 호출해도 OS자체에서 한 프로세스만 down하도록 한다.

만약 producer가 down mutex를 하면 1에서 0으로 바꾸어 먼저 수행하고, consumer는 0에서 -1로 바꾸어 실행을 대기한다(sleep).

이후 producer가 작업을 수행하고 임계 영역을 나올 때 mutex를 up하면 -1에서 0로 바뀌고 sleep을 호출한 프로세스(consumer)를 깨워주고 consumer은 바로 semaphore을 획득하여 임계 영역에 들어가 바로 실행하게 된다.

Priority Inversion(우선순위 역전)

sleep과 wakeup이 수행될 때 우선순위를 기반으로한 선점 스케줄링(priority-based preemptive scheduling scheme)에서 우선순위 역전이 일어날 수 있다.

우선순위: T1 > T2 > T3

T3이 필요한 데이터를 Lock을 하여 실행중인데, T1이 깨어나서 수행 시 T3이 Lock을 한 데이터를 필요로 한다. 이 때 T1은 T3이 수행 종료되어 Lock을 반환할 때 까지 기다려야하는데, 그 사이 T2가 스케줄링되어 실행되면 T2가 T1보다 먼저 수행되며 종료하는 우선순위 역전이 생길 수 있다.

Priority Inheritance

T1의 우선순위를 T3에게 상속하여 T3 수행 중에 T2는 깨어나도 T3이 우선순위가 더 높기 때문에 T3이 수행 종료된 후 수행된다.

Mutexes

Semaphore는 OS에 시스템 호출을 함으로써 상호배제를 구현한다. 반대로 Mutex는 OS에 부탁하지 않고 독립적으로 상호배제를 할 수 있는 방법이다.
Mutex는 쓰레드들 간에 OS 공유없이 가능한 공유방법으로, 하나의 프로세스 내에서 TSL연산을 그대로 이용할 수 있다.
따라서 Mutex는 멀티 쓰레드로 구현하고 싶을 때 효율적일 수 있다.

TSL과 마찬가지로, registe는 mutex를 1로 세팅하고, 이전값이 0이었다면 return하고 1이었다면 mutex가 수행중(다른 쓰레드 스케줄중)이므로 처음부터 다시수행하며 대기한다.

Mutexes in pthreads

대부분의 OS는 Mutex연산을 제공하여 하나의 프로세스 안에서 멀티 쓰레드로 일을 할 때 사용하는것이 가능하다!
하지만 mutex는 semaphore과는 다르게 동기화(sleep-wakeup)는 해주지 못하기 때문에 condition 변수를 도입하였다.

Pthread 패키지, mutex 변수를 생성하거나(init) 삭제(destroy), lock, unlock등의 기능을 제공한다. signal, broadcast를 이용하여 쓰레드를 하나만 깨우거나 모두 깨우는 등의 작업도 가능하

쓰레드를 이용하여 producer-cousumer problem를 해결한 코드. consumer와 producer를 별도의 쓰레드로 생성하여 병렬 실행한다.

이때 만약 producer가 lock을 하고 버퍼가 MAX에 도달하면 unlock하지 않고 잠들게되어 consumer는 이를 깨워줄 수 없게 된다. 따라서 sleep직전에 unlock하도록 설계되어있고, 깨어날 때 lock을 하지 않고 깨면 안되므로 lock을 하고 깨어나도록 하는 코드도 설계되어 있다.

Monitors

up&down연산(high level)과 lock&unlock연산(low level)은 설계시 코드가 수천줄이 넘어가면 up&down쌍을 맞추기 어렵다는 문제점이 있다.
Monitor은 동기화를 프로그래머가 설계하는것이 아니라 컴파일러 수준에서 하도록 설계한 것이다.

모니터. 쓰레드가 동시에 호출해도 컴파일러는 항상 한번에 하나씩만 실행해준다.(상호배제)

모니터로 구현한 producer-cousumer problem.

2개의 쓰레드가 동시에 실행되는 중에 동시에 insert, remove를 부르게 되더라도 컴파일러가 알아서 동시에 실행되지않도록 구현된다.

Structure of a Monitor

프로세스들은 Queue에서 기다리다 하나씩 모니터로 들어와 실행한다.
첫번째 프로세스가 실행하다 sleep하는 코드를 만나면 monitor의 waiting area로 들어가서 기다린다.
그동안 모니터가 비게되면 두번째 프로세스가 들어와서 실행한다.
이때 첫번째 프로세스를 wake up해주는 코드가 있다고 하면 깨워준 이후 두 프로세스는 동시에 수행될수 없으므로
두번째 프로세스는 1) wake up을 시켜주고 바로 urgent Queue로 들어가 기다리고 첫번째 프로세스를 실행하거나 / 2) wake up을 시켜주고 쭉 수행 후 종료된 다음 첫번째 프로세스를 실행할 수 있다.

Hoare's Monitor : 1) 방법. 안멈추고 실행시 이후 코드에 따라 다른 일을 하게되면 조건이 훼손될 수 있다는 이유가 명확하다.
Lampson&Redell's Monitor: 2) 방법. 첫번째 프로세스가 깨어나면 바로 실행(if문으로 작성)하는것이 아니라 처음 코드로 다시 돌아가서(while문으로 작성) count가 0인지 확인하는 등의 작업을 하여 조건 훼손 가능성(에러 가능성)이 없도록 구현하였다.

Lock-free Data Structure

CPU의 core수가 많아져서 공유 변수를 수정할 때 Lock이 병목현상을 일으킬 수 있게되어 성능이 떨어질 수 있다.

따라서 CPU는 Atomic한 CAS기능(Compare-and-Swap 명령어)을 제공한다.

Lock-free Push and Pop

push&pop 자료구조의 포인터 위치의 변경을 CAS로 구현할 수 있다.

ABA Problem

Node들이 Linked list로 연결되어있다. head를 Node A에서 B로 변경하는 Thread1을 수행하기 전에 pop을 2번, A를 push하는 Thread2가 수행되면 head가 잘못 옮겨지는 문제가 발생한다.

Synchronization(동기화)

Message Passing

send와 receive를 통해 데이터를 주고받을 수 있다. 이때 destination, source등을 위해 addressing이 필요하다.

Synchronization

Sender와 Receiver는 메세지를 전달될때까지 기다리는동안 blocking될 수도있고 안될수도있다.

Blocking send, blocking receive : sender와 receiver가 메세지가 전달될 때 까지 모두 block된다.
Nonblocking send, blocking receive : sender는 메세지를 보내고 꼭 기다릴 필요 없고(작업 수행) 자기일을 한다. 가장 일반적인 경우.
Nonblocking send, nonblocking receive : sender와 receiver모두 메세지가 전달될 때 까지 block되지 않는다. 이때 메세지를 저장하는 Q가 중간과정에 별도로 존재해야한다!

Addressing

Direct Addressing

process id로 Addressing하는 방법. Addressing시 몇번 process인지 알 수 있다. 하지만 process id는 실행될 때 마다 동작이 할당되기 때문에 프로그램 작성시 몇 번일지 예측할 수 없다.

Indirect Addressing

mailbox(=port, Queue)를 이용하는 방법. 보통 이 방법을 많이 사용한다.
ex) sender은 mailbox 10번에 데이터를 할당 한 후 receiver가 이를 가져간다.

Indirect Process Communication

N개의 message를 이용한 producer-cousumer problem. 메세지 자체를 주고받으므로 임계 영역은 필요하지 않다.

Barriers

모든 쓰레드가 특정 지점(Barrier)에 도달할 때까지 기다렸다가 다음단계를 진행하도록 한다.

a -> b -> c, 모든 프로세스가 Barrier에 도달하면 그 이후 프로세스가 진행된다.

OS - Introduction

Eunbae — Tue, 7 Jun 2022 15:51:25 +0900

Dual Mode of Processors

- OS는 Code data형태로 존재하고, 프로세스는 필요하면 시스템 호출을 통해 Interrupt를 통해 OS code를 실행하고 돌아간다!

-> OS는 프로세스가 아니고, 코드 데이터 형태로 Library처럼 어딘가에 존재하며 프로세스가 언제든 호출할수있도록 준비된 형태로 존재한다.

- 사용자 프로그램은 직접 입출력장치를 구동하면 안되며 유저 모드에서 실행한다. 운영체제 코드는 입출력 장치를 실행할 수 있어야 하므로 CPU의 모드는 OS코드 실행시 자동으로 커널모드로 바뀐다. 이후 interrupt return을 하면 다시 유저 모드로 바뀌게 된다.

- 커널 모드일때만 특권 명령(입출력, 메모리 영역 조절, 프로세서 상태 변경 등)을 실행할 수 있도록 하드웨어적으로 CPU 설계가 되어있다.

Timer interrupt가 주기적으로 수행되며 사용자 프로그램 실행 시 유저모드, OS 코드 실행시 커널모드로 바뀐다.

Buses

예전 PC에선 ISA버스 하나만 존재하였다. 속도가 빨라지며 PCI 버스 추가되었으며 전용 메모리/캐시 버스도 추가되었다. 각 버스의 속도는 다르기 때문에 맞춰주기 위해 bridge회로를 추가하여 사용한다.

System Calls

trap to the kernal : interrupt를 걺, dispatch: interrupt service routine, interrupt return하면 돌아감

시스템 호출을 할 때 interrupt를 건다!

Firebase에서 Github 인증 사용설정하기

Eunbae — Wed, 11 May 2022 15:30:31 +0900

1. Firebase 콘솔에서 승인 콜백 URL 얻기

Firebase 콘솔의 인증창에서 "로그인 방법 설정"버튼을 누르고 로그인 제공업체 탭에서 깃허브를 선택하면 위와같이 승인 콜백 URL와 클라이언트 ID, 비밀번호를 입력하는 창이 뜨게된다.

2. 깃허브 설정에서 OAuth App 등록하기

깃허브로 가서 Settings > Developer Settings > OAuth Apps로 들어가면 새로운 Oauth App을 생성할 수 있다.
생성하기에서 App이름과 홈페이지 URL, 그리고 1번 과정에서 얻은 승인 콜백 URL을 입력해준다.

3. 클라이언트 ID, 비밀번호 등록

생성된 OAuth App에 들어가면 클라이언트 ID와 비밀번호를 얻을 수 있다. 이를 다시 파이어베이스 콘솔창으로 돌아와서 입력해주면 사용 설정된다!

참고 - https://firebase.google.com/docs/auth/web/github-auth?authuser=1

논리회로 및 설계(1)

Eunbae — Fri, 6 May 2022 21:22:47 +0900

Chaper 01 From Zero to One

수업의 목적

컴퓨터 내부에 대해서 배운다.
디지털 설계에 대한 원칙에 대해서 배운다.
마이크로프로세서를 설계 및 구축한다.

Digital Discipline: Binary(이진)

다음과 같은 분리된 두가지 value를 고려한다

1, True, High
0, False, Low

수의 체계 (Number Systems)

Decimal Numbers (십진수) - ex. 5374
Binary Numbers (이진수) - ex. 1101
Hexadecimal Numbers (16진수) - 이진수를 짧게 표현한것, ex. 4AF

5374(10진수) = 5x10^3 + 3x10^2 + 7x10^1 + 4x10^0

1101(2진수) = 1x2^3 + 1x2^2 + 0x2^1 + 1x2^0 = 13(10진수)

4AF(16진수) = 0100 | 1010 | 1111(2진수)

수의 범위 - 십진수: [0, 10^N - 1], 이진수: [0, 2^N-1]

Bits, Bytes, Nibbles ...

Bits - 10010110, 가장 앞에 있는 bit: Most Significant Bit(MSB), 가장 마지막에 있는 bit: Least Significant Bit(LSB)
Bytes & Nibbles - 10110110에서 0110:nibble(4bits), 전체: 1byte(8bits)
Bytes - CEBF9AD7에서 CE: 1 byte, C: nibble

Addition (더하기)

(이진수) 1011 + 0011 = 1110 (올림수-carries 발생)

1011 + 0110 = 10001 : Overflow(오버플로우, 넘침)현상 발생, 4bit로 표현할 수 없음!

Signed Binary Numbers(부호를 가진 수의 표현)

Sign/Magnitude Numbers(부호/절대값)

Sign bit는 MSB, Negative number: sign bit = 1, Positive number: sign bit = 0

N-bit 부호/절대값의 범위: [-(2^(N-1)-1), 2^(N-1)-1]

ex. 1101 = -5, 0101=+5

하지만 다음과 같은 문제가 발생한다.

Addition doesn't work: 1101 + 0101 = 10010 (-5+5!=0)
Two representations of 0: 1000, 0000은 똑같은 0

Two's Complement Numbers(2의 보수)

MSB는 -2^N-1의 value를 가진다.

ex. Most positive 4-bit number: 0111(7), Most negative 4-bit number: 1000(-8)

N-bit 부호/절대값의 범위: [-2^(N-1), 2^(N-1)-1]

2의 보수 표현에서 음수화 작업하는 방법

Invert the bits
Add 1

ex. 0111 -> 1000 -> 1001

Logic Gates

inversion(NOT), AND, OR, NAND, NOR, etc..

트랜지스터(Transistor)

: Three-ported voltage-controlled switch

nMOS transistor: pass good 0's, so connect source to GND
pMOS transistor: pass good 1's, so connect source to VDD

쿠키 - 세션쿠키와 지속쿠키의 차이점(+지속쿠키 설정 방법)

Eunbae — Sat, 12 Mar 2022 03:02:37 +0900

세션쿠키 vs 지속쿠키

세션쿠키(Session Cookie) : 세션쿠키는 메모리에 저장되어(디스크x) 브라우저가 종료되면 삭제된다.
지속쿠키(Persistent Cookie) : 지속쿠키는 디스크에 저장되어 브라우저가 종료되거나 심지어 컴퓨터가 재시동 되더라도 남아있다. 만료 시간이 존재하고, 만료되면 삭제되는것이 특징이다. 예시로 Google Analytics Cookie가 있다.

→ 쿠키 저장시 Max-Age, Expires값을 설정한다면 저장 기한이 있는 지속쿠키로 저장되고, 이 두 값을 설정하지 않고 저장하면 자동으로 세션쿠키로 저장된다.

react-cookie에서 지속쿠키 설정 방법

const cookies = new Cookies();
cookies.set('ACCESS_TOKEN', res.data.accessToken, { maxAge: 2 * 60 * 60 }); // 단위: 초, 2시간

const cookies = new Cookies();
const expires = new Date();
expires.setFullYear(expires.getFullYear() + 1);
cookies.set('ACCESS_TOKEN', res.data.accessToken, { expires: expires });

: maxAge값을 주어 현재 시간부터 기간을 설정하거나, expires값을 주어 만료 시간을 직접 설정하게 되면 지속쿠키로 설정할 수 있다.

여담으로 프로젝트에서 쿠키에 저장된 Access Token의 저장기한을 주도록 구현하기 위해 관련 내용을 조사했는데, 이대로 구현한다면 토큰은 지속쿠키가 되었다. 하지만 브라우저가 종료되면 로그인 정보도 사라지도록 구현해야 했기 때문에 결국 세션쿠키로 구현하였다..ㅜ^ㅜ

참고문서

- https://www.cookiepro.com/knowledge/what-is-a-persistent-cookie/

- https://www.npmjs.com/package/react-cookie

box-sizing : border-box 이용하기

Eunbae — Sat, 5 Mar 2022 15:09:14 +0900

✔️ box-sizing 속성은 요소(element)의 너비와 높이를 계산하는 방법을 지정한다.

content-box는 css의 기본 설정으로, 크기값을 컨텐츠 영역에 적용하고 border와 padding값은 추가로 더해진다.

border-box는 border와 padding도 요소의 크기값에 포함하기 때문에 컨텐츠 영역이 줄어들게 된다.

예를 들어 content-box설정에서 height값을 100px주고, padding값을 10px, border를 5px주게되면 총 높이는 100+10*2+5*2=130px가 된다.

반면 border-box설정을 주게되면 총 높이는 padding값과 border값과는 상관없이 100px이 된다.

텍스트 중앙 정렬을 위해 padding-top값을 3.5px주었더니 컨텐츠 영역에 21px가 적용되어 총 높이가 26.5px가 되어버렸다.

이를 해결하기 위해 box-sizing: border-box를 주었고, 높이값이 원하는 값인 21px로 적용되었다!

수정 전 -> 수정 후

참고 - https://developer.mozilla.org/ko/docs/Web/CSS/box-sizing

Iroom 클론 프로젝트 기록

Eunbae — Sun, 28 Nov 2021 02:09:27 +0900

✔️ 작업 기간

2021.11.05~2021.11.26

✔️ 팀원 구성

Front-end(3명) : 공은배, 서지수, 조은

✔️ 깃허브 주소

https://github.com/jseo9732/iroom-clone

GitHub - jseo9732/iroom-clone: 모임공간이룸 클론코딩 - https://www.iroomstudy.com/

모임공간이룸 클론코딩 - https://www.iroomstudy.com/. Contribute to jseo9732/iroom-clone development by creating an account on GitHub.

github.com

✔️ 사용 기술 스택

HTML, CSS
React, React Hooks, React Router
JavaScript (ES6)
Firebase (Back-end)
GitHub

✔️ 파트별 기능 구현

메인 페이지 (Main)

Navigation component
Footer component
Router

소개 페이지 (Introduction)
예약 페이지 (Reservation)
마이 페이지 (Profile)
로그인 페이지 (Login)

회원가입 및 로그인

✔️ 나의 작업 부분

예약신청 및 마이페이지에서 확인, 취소기능

예약 페이지(Reservation)

예약 모달창 구현
예약 정보 전송 (→Firebase)

마이 페이지(Profile)

마이페이지 레이아웃 구현
예약 정보 표시 및 삭제기능 구현

✔️ 작업 기록 (예약 페이지)

모달창 구현

export default function Reservation({userObj, isLoggedIn}) { const [IsopenReserveModal, setIsOpenReserveModal] = useState(false); const toggleReserveModal = () => { setIsOpenReserveModal((prev) => !prev) } ... { openReserveModal && <ReserveModal toggleReserveModal={toggleReserveModal} /> }

예약하기 버튼을 눌렀을 때 toggleReserveModal 함수를 실행하여 useState의 현재 상태를 true로 바꾸고, 값이 true일 때 ReserveModal 컴포넌트를 띄우는 방식으로 모달창 띄우기를 구현하였다.
또한 상태를 바꾸는 함수를 ReserveModal 컴포넌트로 줘서 모달 창에서 닫기 버튼을 눌렀을 때 이 함수를 실행하는 방식으로 모달창 닫기를 구현하였다.

useNavigate 이용해 Redirect 구현

 const navigate = useNavigate(); const redirectLogin = () => { window.alert("로그인 후 이용해주세요"); navigate('/login'); }

{ openReserveModal && ( isLoggedIn ? <ReserveModal uid={userObj.uid} username={userObj.displayName} isLoggedIn={isLoggedIn} toggleReserveModal={toggleReserveModal} /> : redirectLogin()) }

Firebase로 데이터 전송

const {phoneNum, room, reserveDate, reserveTime, reserveRemainTime} = reserveInputs; const onReserveSubmit = async (e) => { e.preventDefault(); const reserveObj = { ...reserveInputs, createdAt: Date.now(), userId: uid, } if (phoneNum && room && reserveDate && reserveTime && reserveRemainTime) { const ok = window.confirm("위의 정보로 예약하시겠습니까?"); if(ok) { try { await setDoc(doc(dbService, "reservations", `${reserveObj.createdAt}`), reserveObj); } catch (e) { console.error("Error adding document: ", e); } setReserveInputs({ phoneNum: "", room: "", reserveDate: "", reseveTime: "", reserveRemainTime: "", }) toggleReserveModal(); window.alert("예약되었습니다"); } } else { window.alert("정보를 전부 입력해주세요"); } }

✔️ 문제 해결

여러개의 input 통합하여 관리하기

const [phoneNum, setPhoneNum] = useState(""); const [room, setRoom] = useState(""); const [reserveDate, setReserveDate] = useState(""); const [reserveTime, setReserveTime] = useState(""); const [reserveRemainTime, setReserveRemainTime] = useState(""); const onPhoneNumChange = (e) => { const { target : { value } } = e setPhoneNum(value); } const onRoomChange = (e) => { const { target : { value } } = e setRoom(value); } const onReserveDateChange = (e) => { const { target : { value } } = e setReserveDate(value); } const onReserveTimeChange = (e) => { const { target : { value } } = e setReserveTime(value); } const onReserveRemainTimeChange = (e) => { const { target : { value } } = e setReserveRemainTime(value); }

const [reserveInputs, setReserveInputs] = useState({ phoneNum: "", room: "", reserveDate: "", reseveTime: "", reserveRemainTime: "", }); const onReserveChange = (e) => { const { target : { value, name }} = e setReserveInputs({ ...reserveInputs, [name] : value }) }

예약하기에서 예약 정보를 받을 때 정보들을 input과 select값 여러개로 받게되어 useState를 각각의 값마다 작성하였다.
하지만 이렇게 작성하니 코드도 길어지고, 가독성이 떨지는 문제점이 생겼다.
이를 useState에 받은 전체 값들을 객체로 저장하였고, 값이 변경되었을 때 spread문법을 이용하여 저장하는 방식으로 코드를 고쳐서 개선하였다.

✔️ 프로젝트 후기

리액트 스터디를 다 진행하고, 스터디 팀원들이 다 프론트쪽이라 백엔드를 따로 구하기는 애매해서 파이어베이스를 사용하여 프로젝트를 진행하기로 하였고, 이를 위해 노마드코더의 트위터 클론코딩 강의를 스터디원들끼리 각 파트를 분배하여 정리하며 공부하였다. 강의정리를 마친 후 3명이서 모임공간이룸 홈페이지 클론을 진행하였는데, 이 사이트에서 예약은 네이버예약으로 받았기에 우리가 예약 기능과 로그인 기능, 예약 정보를 볼수있는 마이페이지를 추가하였다. 그중 나는 예약페이지랑 마이페이지의 기능 구현을 맡았고 이를 구현하기 위해 모달창 생성, Firebase로 데이터 전송 및 불러오기, 불러온 데이터 표시 등 다양한 작업을 할 수 있었다.

느낀 점

어떤 프로젝트를 진행하며 협업을 하는것이 처음이라 시작할 때는 막연함에서 온 무서움(내가 깃허브에 커밋을 잘못해서 꼬여버리면 어떡하지? 와 같은..) 도 있었지만 프로젝트를 진행해보니 별거 아닌 걱정이었다. 일단 시작해봐야 배울점이 많다는것을 깨달았다.
또 슬랙과 깃허브를 이번 기회에 처음 사용해보았다. 특히 깃허브를 사용하여 프로젝트를 관리하는것이 어색하고 잘 사용할 수 있을지 걱정했는데, 계속 커밋, 풀, 푸시 등을 이용하여 사용하니까 이 과정들이 익숙해졌고 깃을 이용해 버전관리를 하는 전체적인 흐름을 어느정도 이해하게 되었다.
Firebase를 이용하여 프로젝트를 진행하면서 NoSQL기반의 데이터베이스 구조에 대해 조금 더 공부할 수 있었고, 공식문서가 잘 나와있어서 문서를 읽어가며 공부하였고, 공식문서를 읽는 것도 조금은 더 익숙해진거같다. 그런데 Firebase를 이용하면 코드가 간결하고 작업이 줄어서 좋긴 했지만, SQL을 사용한 db를 연결하여 작업을 해보고 싶은 아쉬움도 있었다.
이번 프로젝트를 진행하며 아직 많이 부족하고 배워야할 부분도 많다는 것을 절실히 깨달았고, 다음에는 백엔드 개발자도 포함된 더 큰 규모의 프로젝트 진행해보고 싶고, TypeScript 언어나 Redux 사용법도 배워서 이를 이용한 프로젝트도 해 봐야겠다고 생각했다.