컴퓨터 아키텍처와 RISC-V

Unknown — Fri, 10 Apr 2026 00:00:00 +0000

컴퓨터 아키텍처와 RISC-V CPU의 구조에 대해 알아보겠습니다.

본 글의 내용은 포항공과대학교의 CSED311의 내용을 기반으로
수업에서 다루지 않은 몇몇 내용을 추가하여 구성하였습니다. </blockquote>

아키텍처란?</h1>

컴퓨터 아키텍처는 하드웨어와 소프트웨어 사이의 인터페이스 규약입니다. 구체적으로는 CPU가 이해하는 명령어 집합(ISA, Instruction Set Architecture)을 중심으로, 아래 내용들을 정의합니다.

명령어(인스트럭션): 어떤 연산(덧셈,분기,메모리 접근 등)을 지원하고 어떤 형식으로 표현하는가</li>
레지스터: 레지스터가 몇 개이고, 각각 몇 비트인가, 각각의 용도는 무엇인가</li>
메모리 모델: 주소 공간 크기, 바이트 순서(엔디언)</li>

예외/인터럽트 처리: 오류나 외부 이벤트를 어떻게 다루는가</li> </ul>

아키텍처는 실제 하드웨어적 구현과 무관하게 동일하게 유지되는 추상 계층 입니다. 컴파일러가 이 규약만 보고 해당 아키텍처에 맞는 코드를 생성하면, 해당 아키텍처를 구현한 어떤 칩에서든 동작합니다. 따라서 제조사가 다르더라도 아키텍처가 같으면 유저는 동일한 OS와 응용 프로그램을 실행할 수 있습니다. (AMD와 Intel의 x86-64 CPU를 생각할 수 있습니다)

반면 마이크로 아키텍처는 아키텍처라는 "약속"을 실제 하드웨어로 구현하는 내부 설계입니다. 파이프라인, 비순차 실행, 분기 예측 등 최적화나 세부적인 구현이 마이크로 아키텍처에 해당합니다.

아키텍처의 유형</h2>
컴퓨터 아키텍처의 주요 유형에는 폰 노이만 아키텍처, 하버드 아키텍처, 데이터플로우 아키텍처 등이 있습니다.
폰 노이만 아키텍처</h3>
폰 노이만 아키텍처는 존 폰 노이만이 제안한 컴퓨터의 기본 구조로, 오늘날 거의 모든 범용 컴퓨터의 토대가 됩니다. 폰 노이만 아키텍처 이전의 컴퓨터(ENIAC 등)는 프로그램을 바꾸려면 물리적으로 배선을 변경해야 했습니다.
당시 ENIAC을 개발한 모클리와 에커트는 후속 컴퓨터 EDVAC을 설계하면서 프로그램과 데이터를 같은 메모리에 저장하는 방법을 구상합니다. 이렇게 하면 프로그램을 메모리에 올리기만 하면 하나의 배선으로 서로 다른 작업을 수행할 수 있다는 장점이 있습니다. (이후 폰 노이만이 이 아이디어를 정리한 보고서를 단독 저자로 배포하게 되면서, 이러한 구조의 이름이 폰 노이만 아키텍처가 되었습니다.)
폰 노이만 아키텍처는 CPU가 메모리에서 명령어를 가져오고, 해석하고, 실행하는 과정을 반복하여 프로그램을 실행합니다. 이때 명령어와 데이터가 같은 메모리, 같은 데이터 버스를 공유하기 때문에, CPU가 아무리 빠르더라도 메모리 대역폭에 의해 성능이 제한되는 폰 노이만 병목(Von Neumann Bottleneck)이 일어납니다. 이러한 이유로, 현대 CPU는 폰 노이만 아키텍처를 기반으로 하지만, 전통적인 폰 노이만 아키텍처의 구조를 그대로 사용하지 않고, 아래 하버드 아키텍처의 구조와 적절히 결합하여 사용합니다.
하버드 아키텍처</h3>
하버드 아키텍처는 폰 노이만 아키텍처와 비슷한 시기 하버드 대학의 Mark I 컴퓨터에서 유래한 아키텍처입니다. Mark I은 명령어를 펀치 테이프에서, 데이터를 기계식 카운터에서 따로 읽었기 때문에, 폰 노이만 아키텍처와 달리 명령어 메모리와 데이터 메모리를 물리적으로 완전히 분리한 구조를 가집니다.
하버드 아키텍처는 명령어와 데이터의 버스를 구분하여 명령어와 데이터를 동시에 읽을 수 있기 때문에, 처리량이 높다는 장점이 있습니다. 하지만 두 메모리간의 용량을 유연하게 나눌 수 없고, 프로그램을 명령어 메모리로 옮기는 별도 메커니즘이 필요합니다. 현대에는 마이크로컨트롤러(아두이노에 들어가는 AVR 등)나 DSP(디지털 신호 처리기) 같은 일부 분야에서 하버드 아키텍처가 이용됩니다.
수정된 하버드 아키텍처</h3>
수정된 하버드 아키텍처는 현대 CPU 대부분이 채택한 폰 노이만 아키텍처와 하버드 아키텍처 사이의 절충안입니다. L1 캐시 레벨에서 I-cache와 D-cache를 분리해 하버드 아키텍처의 높은 대역폭이라는 이점을 취하고, 그 이하의 메모리는 통합하여 폰 노이만 아키텍처의 유연성을 유지합니다. CPU 입장에서는 L1 캐시의 메모리가 명령어와 데이터로 분리되어 있으므로 하버드 아키텍처처럼 동작하지만, 캐시를 직접 다루지 않는 컴파일러와 프로그래머의 입장에서는 하나의 주소공간으로 컴퓨터를 다룰 수 있습니다.
데이터플로우 아키텍처</h3>
데이터플로우 아키텍처는 위 하버드 아키텍처나 폰 노이만 아키텍처와 근본적으로 다른 아키텍처 패러다임입니다. 폰 노이만 방식은 프로그램 카운터가 "다음에 실행할 명령어"를 순차적으로 지정합니다. 데이터플로우 아키텍처는 이러한 폰 노이만 방식의 순차적인 연산 시행이라는 한계를 탈피하기 위해 설계된 아키텍처로, 프로그램 카운터가 없습니다. 데이터플로우 아키텍처에서는 프로그램 카운터가 순차적으로 어떤 명령어를 수행할지 지정하지 않아도 필요한 데이터가 전부 준비되면 명령어가 즉시 실행됩니다. 프로그램의 실행 순서를 프로그래머나 하드웨어가 정하는 것이 아니라, 데이터 자체가 실행 흐름을 결정하는 것입니다.
데이터플로우 아키텍처에서 프로그램은 순차적인 명령어 목록이 아니라, 방향 그래프로 표현됩니다. (a + b) * (c - d)</code>와 같은 연산을 시행할 때, 덧셈 노드와 뺄셈 노드는 서로 의존성이 없으므로 동시에 실행됩니다. 두 연산의 결과가 모두 곱셈 노드에 도착하면 곱셈 연산이 발화(fire)합니다. 명시적으로 프로그래머가 병렬 연산을 지정하지 않아도, 자동으로 모든 연산이 병렬적으로 시행되는 것입니다.
1970년대 처음 등장한 데이터플로우 아키텍처는 1980-1990년대 차세대 컴퓨터로 활발하게 연구되었으나, 다양한 한계로 인해 상용화에는 실패합니다. 데이터플로우 아키텍처에 필요한 연산들이 하드웨어적으로 매우 비싸기도 했고, 대규모 데이터 구조를 다룸에 있어서의 어려움, 기존의 모든 소프트웨어 인프라가 순차 실행 모델을 전제로 작성되어 있다는 복합적인 문제 때문이었습니다.
순수한 데이터플로우 컴퓨터는 현재 사라졌지만, 아이디어는 현대까지 남아 이어지고 있습니다. 폰 노이만 모델 안에서의 비순차 실행(OoO) 구조, FPGA에서의 회로 설계 등에서 데이터플로우 아키텍처의 설계 사상이 이어지고 있고, 최근에는 AI 가속 프로세서 들이 데이터플로우 원리를 하드웨어에 다시 적용하고 있어, 비록 범용 컴퓨팅 머신으로 상용화되지는 않았지만, 다양한 특수 목적 하드웨어에서 데이터플로우 아키텍처를 이용하려는 연구가 지속되고 있습니다.
ISA</h2> ISA는 Instruction Set Architecture의 약자로, 소프트웨어와 하드웨어 사이의 인터페이스라고 할 수 있습니다. ISA는 아래와 같은 사항들을 결정합니다. 명령어 세트에 어떤 연산이 존재하는지, 각 명령어의 인코딩 형식은 어떤지</li> 하드웨어가 직접적으로 지원하는 데이터 타입에는 어떤 것들이 있는지, 바이트 순서는 어떤지 (리틀 엔디언, 빅 엔디언)</li> 레지스터 구성과 레지스터의 개수, 비트폭과 용도</li> 주소 지정 방식 (Addressing Mode)와 명령어가 피연산자의 위치를 어떻게 지정하는지</li> 메모리 모델의 주소 공간 크기</li> 어떤 상황(0으로 나누기, 페이지 폴트, 잘못된 명령어)에서 예외가 발생하는지, 인터럽트는 어떻게 처리되는지</li> 권한 수준과 보호 모드/커널 모드의 구분, 각 모드에서 접근 가능한 레지스터와 명령어의 범위, 가상 메모리 관련 부분</li> </ul> 반면, ISA 아래에 위치하는 마이크로아키텍처와 관련된 부분(클럭 속도, 파이프라인 단계, 캐시 구조 등)과 소프트웨어 계층의 규약들(ABI, 메모리 맵, 펌웨어 인터페이스)은 ISA가 지정하지 않습니다. Programmer Visible State는 ISA에서 프로그래머(컴파일러)가 명령어를 통해 직접 읽거나 쓸 수 있는 모든 하드웨어 상태입니다. 프로그램의 의미(sementics)는 이 상태들의 변화로 정의됩니다. 구체적으로는 범용 레지스터, 프로그램 카운터, 스택 포인터, 플래그 레지스터, 메모리 주소 공간 전체 등이 해당합니다. 이와 반대로 보이지 않는 상태(microarchitectural state)는 캐시 내용, 분기 예측기의 히스토리, 리오더 버퍼, 예약 스테이션, 물리 레지스터 파일, TLB 엔트리 등이 있습니다. 이들은 성능에만 영향을 주고, 프로그램의 논리적인 결과를 바꾸지 않습니다. 같은 ISA를 구현한 어떤 칩에서든 Programmer Visible State의 변화가 동일하면 정확한 구현이고, 그 외의 내부 상태는 자유롭게 다를 수 있습니다. ISA가 제공하는 명령어들을 기능별로 분류하면 아래와 같이 나눌 수 있습니다. 산술/논리 연산(Arithmetic/Logical): 레지스터나 즉시값에 대해 연산을 수행합니다. 결과는 보통 레지스터에 저장되고, 부수적으로 플래그가 갱신됩니다.</li> 데이터 이동(Data Transfer/Memory): 레지스터와 메모리, 또는 레지스터 간에 데이터를 옮깁니다.</li> 제어 흐름(Control Flow): 프로그램 카운터를 변경해 실행 흐름을 바꿉니다. 무조건 분기(Jump), 조건 분기(Branch), 함수 호출/복귀 등이 있습니다.</li> 시스템 명령어(System/Privileged): OS나 하드웨어의 제어를 위한 명령어입니다. 사용자 모드에서 커널로 진입, 인터럽트 제어 등이 있습니다. 현대 마이크로프로세서에서는 이런 명령어는 대부분 커널 모드에서만 실행 가능하고, 유저 모드에서 실행하면 예외가 발생합니다.</li> </ul> 이러한 명령어는 반드시 원자적으로(Atomicity) 실행되어야 합니다. 하나의 명령어는 Programmer Visible State를 여러 개 변경할 수 있지만, 이러한 중간 변경 과정은 프로그래머에게 노출되어서는 안됩니다. 실제 하드웨어에서는 파이프라인에서 레지스터를 먼저 쓰고, PC를 나중에 갱신하는 식으로 명령어를 단계적으로 처리할 수 있지만, 이는 Microarchitectural State이지, Programmer Visible State가 아닙니다. ISA의 역사</h2> EDSAC</h3> EDSAC은 최초의 저장 프로그램 컴퓨터 중 하나로, 아주 단순한 ISA를 가지고 있습니다. 명령어는 5비트 opcode + 예약 비트 + 10비트 메모리 주소(n)로 구성되며, 단일 누산기 (Accumulator) 구조입니다. 레지스터는 Acc 하나뿐이고, 모든 연산은 이 Acc 레지스터를 중심으로 돌아갑니다. 명령어의 예시는 아래와 같습니다. A n: M[n]</code>을 ACC</code>에 더합니다</li> T n: ACC</code>의 내용을 M[n]</code>으로 옮기고 ACC를 비웁니다</li> E n: ACC>=0</code>이라면, M[n]</code>으로 점프합니다</li> I n: 테이프로부터 다음 글자를 읽고, M[n]</code>이 가르키는 주소에 저장합니다.</li> Z : 프로그램을 멈추고 벨을 울립니다.</li> </ul> 모든 메모리 주소가 명령어에 하드코딩 되어 있다는 점이 특징입니다. 하지만 이러면 아래와 같은 문제가 발생합니다. 코드에서 함수를 실행할 경우, 함수는 호출 위치로 복귀해야합니다. 하지만EDSAC은 복귀 주소가 명령어에 하드 코딩 되어있으므로, 같은 함수를 여러 곳에서 호출할 경우 복귀 주소를 지정하기 어려웠습니다.</li> 배열 원소를 접근할 때, 배열의 주소가 명령어에 하드코딩되어 있으므로 루프를 돌면서 배열에 접근하려면 매번 명령어 자체를 수정해서 주소를 바꿔야했습니다.</li> </ol> ISA의 발전</h3> 이러한 문제를 해결하고자, 후대 CPU는 다양한 방식으로 진화해왔습니다. 첫 번째로 레지스터는 누산기 레지스터 하나만을 이용하는 구조에서, 프로그램의 주소 지정을 위한 레지스터가 추가되었고, 현대는 범용 레지스터(GPR, General Purpose Register)가 다수 추가되어 모든 레지스터를 어떤 용도로든 사용할 수 있게 되었습니다. 두 번째로 명령어에 다양한 피연산자를 지정할 수 있게 되었습니다. EDSAC 처럼 명령어가 암묵적인 피연산자(ACC)를 가지고 명시적 피연산자는 하나 뿐인 구조를 Monadic, OP inout, in2</code> 처럼 피연산자가 2개이고 입력 중 하나가 결과로 덮어쓰이는 구조를 Dyadic, OP out, in1, in2</code>와 같이 출력과 입력 2개를 모두 명시하는 구조를 Triadic이라고 합니다. 후술할 CISC 아키텍처에서는 ADD [mem], reg</code>와 같이 명령어 하나로 메모리 접근과 연산을 동시에 수행할 수 있는 반면, RISC 아키텍처에서는 메모리 접근은 load/store 만으로 합니다. (load-store architecture) 세 번째로 명령어에 다양한 메모리 주소를 지정할 수 있게 되었습니다. Absoulte - LD rt, 100</code>: EDSAC과 같이 주소가 명령어에 상수로 지정된 방식입니다.</li> Register Indirect - LD rt, (r_base)</code>: 레지스터에 들어가 있는 값을 주소로 사용합니다. 포인터 역참조가 이런 방식입니다.</li> Displaced - LD rt, offset(r_base)</code>: 레지스터 값에 상수 오프셋을 더해 주소를 만듭니다. 구조체 접근에 유용합니다.</li> Indexed - LD rt, (r_base, r_index)</code>: 두 레지스터 값을 더해 주소를 만듭니다.</li> Memory Indirect - LD rt, ((r_base))</code>: 메모리 주소에서 값을 읽고, 그 값을 다시 주소로 사용합니다. 이중 포인터 역참조에 해당합니다.</li> Auto increment/decrement - LDR rt, (r_base)</code>: 레지스터 값을 주소로 사용하되, 접근 전이나 후에 레지스터 값을 자동으로 증가/감소 시킵니다. 배열을 순차적으로 순회할 때 유용합니다.</li> </ul> RISC의 등장</h3> 초기의 CPU 발전은, 단순했던 ISA를 점점 복잡하게 하고, 명령어 세트에 다양한 기능들을 넣으며 진행되었습니다. 당시에는 어셈블리로 직접 프로그래밍하는 것이 보편적이었으며, 다양한 명령어를 넣음으로서 프로그래머의 코딩을 간편하게 만들 수 있었습니다. 또한, 메모리 크기나 성능이 제한적이었기 때문에, 자주 사용되는 복잡한 연산들을 한번에 처리하는 것이 유용했습니다. 하지만, 이후 컴파일러 기술이 발전하며 프로그래머가 직접 복잡한 어셈블리 명령어를 이용해 프로그래밍하는 경우는 거의 없어졌습니다. 사람이 직접 사용하는 것을 상정하고 만들어진 복잡한 명령어들은 컴파일러가 최적하기 어려웠으며, 명령어마다 실행 시간이나 메모리 접근 횟수가 천차만별이라 파이프라인을 효율적으로 설계하기도 어려웠습니다. 이러한 배경에서 RISC (Reduced Instruction Set Computer)가 등장합니다. 모든 명령어의 크기는 같은 크기로, 메모리 접근은 반드시 지정된 명령어로, 각 명령어는 단순하게 하되 레지스터를 넉넉하게 제공하는 등의 명령어 세트를 단순하게 만들자는 철학으로 만든 RISC CPU는 복잡성을 하드웨어에서 컴파일러로 이동하고, 하드웨어를 단순하게 만드는 대신, 최적화 부담은 발전한 컴파일러에 넘깁니다. RISC는 파이프라인을 쉽게 만들 수 있고, 클럭을 높이기에도 유리했습니다. 하드웨어가 단순하므로 트랜지스터를 캐시, 분기 예측기등 성능에 도움이 되는 곳에 투자할 수 있고, 검증과 디버깅이 쉬웠으며 설계 사이클도 짧았습니다. RISC와 대비하여 RISC 이전의 아키텍처들(x86, M68K, Z80 등)을 CISC (Complex Instruction Set Computer)라고 부르는데, M68K, Z80등 많은 CISC 아키텍처들은 사라졌지만, x86은 거대한 소프트웨어 생태계 때문에 사라지지는 않고, 대신 외부 ISA는 CISC, 내부적으로는 RISC라는 절충안을 채택하여 복잡한 명령어를 CPU 내부적으로 RISC로 분해하여 처리하는 설계를 도입했습니다. 현대 RISC 아키텍처의 대표 주자로는 ARM이 있는데, ARM은 초기에 간단한 설계를 통한 높은 전성비(전력 당 성능비)를 무기로 새로운 분야인 모바일 시장에 빠르게 진출했고, 2020년대 이전까지는 RISC 아키텍처는 모바일, 임베디드 등 저전력 설계에서, CISC 아키텍처는 고전력을 소모하는 대신 높은 성능을 필요로 하는 워크스테이션이나 데스크탑, 서버 환경에서 이용되어 왔습니다. 하지만 2020년대 이후 Apple Silicon에서 M1 칩을 출시하면서 이러한 상황이 크게 역전되었습니다. 애플의 M1 등 ARM CPU는 RISC 아키텍처 기반의 CPU가 높은 성능과 CISC CPU보다 개선된 전성비로 빠르게 시장 점유율을 늘려나가고 있으며, 애플 이외에도 ARM Windows/Linux 노트북이 판매되는 등 모바일 시장 이외에도 RISC 아키텍처가 점유율을 조금씩 늘려가고 있습니다. RISC-V</h1> RISC-V는 2010년에 UC Berkeley에서 시작된 오픈소스 ISA입니다. 1981년에 설계된 최초의 RISC 프로세서인 RISC-I, RISC-II에 지난 30년간의 교훈을 반영해 레거시 없이 깨끗한 RISC ISA를 처음부터 설계했습니다. (V는 Berkeley에서 개발한 다섯 번째 RISC 설계라는 뜻입니다. RISC-I, RISC-II, SOAR, SPUR, RISC-V) RISC-V는 특정 회사에 종속된 ARM이나 x86과 달리, 누구나 무료로 RISC-V ISA를 구현한 프로세서를 만들 수 있고, 스타트업, 학교, 대기업 모두 자유롭게 칩을 설계할 수 있습니다. 또한, 모듈식 설계를 이용해 하나의 거대한 ISA가 아니라, 최소한의 명령어를 가진 작은 ISA에 필요한 확장을 붙히는 구조로 개발되었습니다. RISC-V의 Programmer Visible State</h2> RISC-V에는 기본적으로 x0부터 x31까지 32개의 정수 범용 레지스터가 있습니다. x0은 항상 0으로 고정된 상태인데, 이는 x0을 0으로 고정함으로서 다양한 동작을 기존 명령어로 표현함으로서 명령어 가짓 수를 줄일 수 있기 때문입니다. (예를 들어, NOP를 ADDI x0, x0, 0</code>으로, 즉시값 로드를 ADDI x1, x0, 42</code>로 표현할 수 있습니다.) 또한, 범용 레지스터에 포함되지 않는 PC 레지스터와 부동소수점 연산을 제공하는 F/D 확장에 포함되는 부동소수점 레지스터 등이 존재합니다. 메모리는 바이트 주소 지정 방식이며, 기본적으로 리틀 엔디언 방식입니다. 메모리의 모든 바이트는 Programmer Visible State이며, 기본적으로 리틀 엔디언 정렬을 이용합니다. RISC-V의 확장 체계</h2> RISC-V는 작은 기본 ISA에 필요한 확장을 조합하여 사용하는 구조입니다. 기본이 되는 ISA는 아래와 같습니다. RV32I : 32비트 정수 기본. 정수 산술/논리, load/store 등 최소한의 명령어만을 가집니다.</li> RV64I : 64비트 정수 기본. RV32I에 64비트 연산과 더블워드 명령어가 추가됩니다.</li> RV128I : 128비트 정수 기본. 다만 64비트보다 큰 주소 공간이 언제 필요할지는 아직 불분명하기 때문에, 사양이 완전히 확정(frozen)되지는 않은 상태입니다.</li> RV32E, RV64E : 임베디드용 축소 ISA, 레지스터를 32개에서 16개로 줄여 극소형 마이크로컨트롤러의 비용을 낮춥니다.</li> </ul> 여기에 아래와 같은 표준 Extension 들이 존재합니다. M : 정수 곱셈, 나눗셈 : MUL</code>, MULH</code> 등 하드웨어 곱셈기의 네이티브 정수 곱셈 연산 명령어를 추가합니다. 극소형 임베디드 기기에서는 하드웨어 곱셈 없이 곱셈과 나눗셈을 비트연산 등 다른 연산으로 대체할 수 있기 때문에, 곱셈과 나눗셈이 별도의 확장으로 분리되어 있습니다.</li> A : 원자적 연산 : 멀티 코어 환경에서 코어 간 메모리 공유를 위한 명령어입니다. 메모리에 대한 쓰기나 읽기를 원자적으로 수행하거나, 메모리를 예약하는 기능 등이 정의되어 있습니다.</li> F : 32비트 부동소수점 연산 : FPU를 통한 하드웨어 부동 소수점 연산을 추가합니다. 32개의 부동소수점 레지스터 f0-f31과 부동 소수점 연산의 결과를 기록하는 플래그인 fcsr이 추가됩니다.</li> D, Q : 각각 64비트 배정밀도 부동소수점 연산과 128비트 4배정밀도 부동소수점 연산 명령어를 추가합니다.</li> C : 자주 쓰는 명령어를 16비트로 인코딩할 수 있게 합니다. 코드의 크기를 줄일 수 있어 플래시 메모리 크기가 크게 제한되는 임베디드 환경에서 사용할 수 있습니다.</li> V : 벡터 확장. SIMD와 유사한 다양한 벡터 연산을 지원합니다.</li> H : 하이퍼바이저 확장. 하이퍼바이저가 지원하는 가상화 계층을 지원합니다.</li> </ul> 이외에 단일 알파벳 대신, 확장 이름 앞에 Z를 붙힌 세분화된 확장들도 있습니다. Zicsr : CSR 접근 명령어</li> Zifencei : 명령어 캐시 동기화, 자기 수정코드, JIT 컴파일시 I-Cache와 D-Cache 일관성 보장</li> Zba, Zbb, Zbc, Zbs : 주소 계산 가속, 기본 비트 연산, 캐리리스 곱셈 등 세부 비트 조작 명령어</li> Zfinx : 부동소수점 연산을 정수 레지스터에서 수행</li> Ztso : Total Store Ordering 메모리 모델 보장. x86 바이너리 변환시 유용</li> Zicond : 조건부 연산. 분기 없이 조건부로 값을 선택</li> </ul> 정말 다양한 확장이 존재하기 때문에 소프트웨어 호환성을 위해 자주 사용하는 확장들을 묶어 정의하는 RISC-V 프로파일이 존재합니다. 예를 들어 RVA20U64는 I, M, A, F, D, C, Zicsr, Zifencei 확장을 필수로 가지도록 정의되어 있습니다. RISC-V 명령어 포멧</h2> RISC-V는 6가지의 기본 명령어 포멧을 정의합니다. RV32I에서 모두 32비트 고정 길이이며, opcode, rd, rs1, rs2의 위치가 포맷 간 최대한 일관되게 배치되어 디코딩을 단순하게 만듭니다. R-Type</h3> 레지스터 간 연산에 사용됩니다. [31:25] [24:20] [19:15] [14:12] [11:7] [6:0] funct7 rs2 rs1 funct3 rd opcode 7비트 5비트 5비트 3비트 5비트 7비트</code></pre> rs1, rs2 두 소스 레지스터로 연산하고 결과를 rd에 저장합니다. funct7</code>와 funct3</code>가 구체적인 연산 종류를 구분합니다. 예: ADD x1, x2, x3</code>: x1 <- x2 + x3 I-Type</h3> 즉시값 연산, load, JALR 등에 사용됩니다. [31:20] [19:15] [14:12] [11:7] [6:0] imm[11:0] rs1 funct3 rd opcode 12비트 5비트 3비트 5비트 7비트</code></pre> 12비트 즉시값이 부호 확장(sign-extend)되어 사용됩니다. R-type에서 funct7</code>과 rs2</code> 자리가 즉시값으로 대체된 형태입니다. 예: ADDI x1, x2, 10</code>: x1 <- x2 + 10 R-type에서 funct7</code>이 빠졌기 때문에, 약간의 명령어 차이가 존재합니다. 예를 들어 R-type에서 funct7</code>으로 구분되는 ADD/SUB의 경우, I-type에서는 음수 즉시값을 쓰면 되므로 명령어 자체가 필요 없어 빠졌고, Immeidate field 를 나눠 세부 명령어를 구분하는 경우도 있습니다. (RV32I 기준 즉시값이 최대 5비트까지만 필요한 SLLI, SRLI, SRAI 등 시프트 명령어는, 앞 7비트를 명령어 지정자로, 나머지 5비트를 시프트 즉시값으로 사용합니다.) 메모리에서 값을 가져오는 Load 명령어 또한 I-Type 인데, opcode</code> 자리에 Load를 의미하는 0000011</code>을 넣고, rs1</code>을 베이스로, 12비트 imm</code>은 오프셋으로 이용합니다. funct3</code>에 따라 32비트를 읽는 LW</code>, 16비트를 읽고 부호 확장하는 LH</code>, 16비트를 읽고 제로 확장하는 LHU</code>, 8비트를 읽는 LB</code>, LBU</code> 등이 구분됩니다. 또한, 즉시값은 항상 12비트로 제한됩니다. 프로그램에서 사용하는 즉시값은 통상적으로 작은 값이고, 큰 상수가 필요한 경우는 통상적으로 드물기 때문에, 최적화를 위한 의도한 설계입니다. 꼭 큰 상수가 필요한 경우에는 후술할 U-type 명령어나 AUIPC 등을 이용해 값을 만들어 쓰게 됩니다. 이는 하나의 명령어로 모든 것을 하려 하지 말고, 간단한 여러 명령어의 조합으로 해결하자는 RISC의 철학을 따른 것입니다. S-Type</h3> 메모리에 값을 저장하는데 사용됩니다. [31:25] [24:20] [19:15] [14:12] [11:7] [6:0] imm[11:5] rs2 rs1 funct3 imm[4:0] opcode 7비트 5비트 5비트 3비트 5비트 7비트</code></pre> 결과를 레지스터에 쓰지 않으므로 rd</code>가 없고, 대신 rd</code> 자리에 즉시값 하위 비트를, funct7</code> 자리에 즉시값의 상위비트를 넣습니다. 예: SW x3, 12(x2)</code>: MEM[x2 + 12]</code> <- x3 B-Type (SB-Type)</h3> 조건 분기에 사용됩니다. [31] [30:25] [24:20] [19:15] [14:12] [11:8] [7] [6:0] imm[12] imm[10:5] rs2 rs1 funct3 imm[4:1] imm[11] opcode 1비트 6비트 5비트 5비트 3비트 4비트 1비트 7비트</code></pre> S-Type과 유사하지만, 즉시값의 비트 배치가 다릅니다. 즉시값이 분기 오프셋으로 사용되며, RISC-V 명령어는 최소 16비트 단위로 정렬되어 분기 오프셋의 최하위 비트는 항상 0이므로 인코딩하지 않습니다. 따라서 13비트 범위의 분기가 가능합니다. 예 : BEQ x1, x2, offset</code>: x1 == x2</code>면 PC <- PC + offset 비트 배치가 특이하게 꼬여있는 이유는 S-type과 최대한 많은 비트 위치를 공유해서 하드웨어를 단순화하기 위함입니다. 이러한 S-Type과의 유사성 때문에 B-Type을 SB-Type이라고 부르기도 합니다. U-Type</h3> 상위 20비트 즉시값을 사용하는 명령어입니다. [31:12] [11:7] [6:0] imm[31:12] rd opcode 20비트 5비트 7비트</code></pre> 20비트 즉시값이 상위 20비트에 배치되고, 하위 12비트는 0으로 채워집니다. I-Type 명령어에서 최대 12비트까지의 즉시값을 사용할 수 있기 때문에, 이를 보완하기 위해 만들어진 명령어입니다. LUI (Load Upper Immedate): rd <- imm << 12, 큰 상수를 만들 때 ADDI와 조합하여 사용합니다. 0x12345678</code>을 만들 때, LUI x1, 0x12345</code>로 상위 20비트를 채우고, ADDI x1, x1, 0x678</code>로 하위 12비트를 채웁니다.</li> AUIPC (Add Upper Immediate to PC): rd <- PC + (imm << 12), PC 상대 주소 계산에 사용되며, JAL과 load와 조합하여 현재 위치에서 ±2GB 범위의 주소를 만들 수 있습니다.</li> </ul> J-Type (UJ-Type)</h3> 무조건 점프에 사용됩니다. [31] [30:21] [20] [19:12] [11:7] [6:0] imm[20] imm[10:1] imm[11] imm[19:12] rd opcode 1비트 10비트 1비트 8비트 5비트 7비트</code></pre> 20비트 즉시값을 점프 오프셋으로 사용하며, B-Type과 동일하게 bit0은 항상 0이므로 인코딩하지 않습니다. 따라서 21비트 범위(±1MB)의 점프가 가능합니다. B-Type과 유사하게, U-Type과 비트 위치를 최대한 공유하도록 설계되어 있습니다. 따라서 UJ-Type이라고 불리기도 합니다. RV32I 명령어 세트</h2> 정수 산술/논리 (R-type)</h3> 명령어</th> 동작</th> 설명</th></tr></thead> ADD rd, rs1, rs2</code></td> rd ← rs1 + rs2</code></td> 덧셈</td></tr> SUB rd, rs1, rs2</code></td> rd ← rs1 - rs2</code></td> 뺄셈</td></tr> AND rd, rs1, rs2</code></td> rd ← rs1 & rs2</code></td> 비트 AND</td></tr> OR rd, rs1, rs2</code></td> rd ← rs1 | rs2</code></td> 비트 OR</td></tr> XOR rd, rs1, rs2</code></td> rd ← rs1 ^ rs2</code></td> 비트 XOR</td></tr> SLL rd, rs1, rs2</code></td> rd ← rs1 << rs2[4:0]</code></td> 논리 좌시프트</td></tr> SRL rd, rs1, rs2</code></td> rd ← rs1 >> rs2[4:0]</code></td> 논리 우시프트 (0 채움)</td></tr> SRA rd, rs1, rs2</code></td> rd ← rs1 >>> rs2[4:0]</code></td> 산술 우시프트 (부호 유지)</td></tr> SLT rd, rs1, rs2</code></td> rd ← (rs1 < rs2) ? 1 : 0</code></td> 부호 있는 비교</td></tr> SLTU rd, rs1, rs2</code></td> rd ← (rs1 < rs2) ? 1 : 0</code></td> 부호 없는 비교</td></tr> </tbody></table> 즉시값 산술/논리 (I-type)</h3> 명령어</th> 동작</th> 설명</th></tr></thead> ADDI rd, rs1, imm</code></td> rd ← rs1 + sext(imm)</code></td> 즉시값 덧셈</td></tr> ANDI rd, rs1, imm</code></td> rd ← rs1 & sext(imm)</code></td> 즉시값 AND</td></tr> ORI rd, rs1, imm</code></td> rd ← rs1 | sext(imm)</code></td> 즉시값 OR</td></tr> XORI rd, rs1, imm</code></td> rd ← rs1 ^ sext(imm)</code></td> 즉시값 XOR</td></tr> SLLI rd, rs1, shamt</code></td> rd ← rs1 << shamt</code></td> 즉시값 논리 좌시프트</td></tr> SRLI rd, rs1, shamt</code></td> rd ← rs1 >> shamt</code></td> 즉시값 논리 우시프트</td></tr> SRAI rd, rs1, shamt</code></td> rd ← rs1 >>> shamt</code></td> 즉시값 산술 우시프트</td></tr> SLTI rd, rs1, imm</code></td> rd ← (rs1 < sext(imm)) ? 1 : 0</code></td> 즉시값 부호 있는 비교</td></tr> SLTIU rd, rs1, imm</code></td> rd ← (rs1 < sext(imm)) ? 1 : 0</code></td> 즉시값 부호 없는 비교</td></tr> </tbody></table> 상위 즉시값 (U-type)</h3> 명령어</th> 동작</th> 설명</th></tr></thead> LUI rd, imm</code></td> rd ← imm << 12</code></td> 상위 20비트 로드</td></tr> AUIPC rd, imm</code></td> rd ← PC + (imm << 12)</code></td> PC 기준 상위 20비트 덧셈</td></tr> </tbody></table> Load (I-type)</h3> 명령어</th> funct3</th> 동작</th> 설명</th></tr></thead> LB rd, imm(rs1)</code></td> 000</code></td> rd ← sext(MEM8[rs1 + sext(imm)])</code></td> 바이트 로드 (부호 확장)</td></tr> LH rd, imm(rs1)</code></td> 001</code></td> rd ← sext(MEM16[rs1 + sext(imm)])</code></td> 하프워드 로드 (부호 확장)</td></tr> LW rd, imm(rs1)</code></td> 010</code></td> rd ← MEM32[rs1 + sext(imm)]</code></td> 워드 로드</td></tr> LBU rd, imm(rs1)</code></td> 100</code></td> rd ← zext(MEM8[rs1 + sext(imm)])</code></td> 바이트 로드 (제로 확장)</td></tr> LHU rd, imm(rs1)</code></td> 101</code></td> rd ← zext(MEM16[rs1 + sext(imm)])</code></td> 하프워드 로드 (제로 확장)</td></tr> </tbody></table> Store (S-type)</h3> 명령어</th> funct3</th> 동작</th> 설명</th></tr></thead> SB rs2, imm(rs1)</code></td> 000</code></td> MEM8[rs1 + sext(imm)] ← rs2[7:0]</code></td> 바이트 저장</td></tr> SH rs2, imm(rs1)</code></td> 001</code></td> MEM16[rs1 + sext(imm)] ← rs2[15:0]</code></td> 하프워드 저장</td></tr> SW rs2, imm(rs1)</code></td> 010</code></td> MEM32[rs1 + sext(imm)] ← rs2</code></td> 워드 저장</td></tr> </tbody></table> 조건 분기 (B-type)</h3> 명령어</th> funct3</th> 동작</th> 설명</th></tr></thead> BEQ rs1, rs2, offset</code></td> 000</code></td> if (rs1 == rs2) PC ← PC + offset</code></td> 같으면 분기</td></tr> BNE rs1, rs2, offset</code></td> 001</code></td> if (rs1 != rs2) PC ← PC + offset</code></td> 다르면 분기</td></tr> BLT rs1, rs2, offset</code></td> 100</code></td> if (rs1 < rs2) PC ← PC + offset</code></td> 부호 있는 미만</td></tr> BGE rs1, rs2, offset</code></td> 101</code></td> if (rs1 >= rs2) PC ← PC + offset</code></td> 부호 있는 이상</td></tr> BLTU rs1, rs2, offset</code></td> 110</code></td> if (rs1 < rs2) PC ← PC + offset</code></td> 부호 없는 미만</td></tr> BGEU rs1, rs2, offset</code></td> 111</code></td> if (rs1 >= rs2) PC ← PC + offset</code></td> 부호 없는 이상</td></tr> </tbody></table> 점프</h3> 명령어</th> 타입</th> 동작</th> 설명</th></tr></thead> JAL rd, offset</code></td> J-type</td> rd ← PC+4, PC ← PC + offset</code></td> 직접 점프 (함수 호출)</td></tr> JALR rd, rs1, imm</code></td> I-type</td> rd ← PC+4, PC ← (rs1 + sext(imm)) & ~1</code></td> 간접 점프 (함수 복귀 등)</td></tr> </tbody></table> 메모리 순서</h3> 명령어</th> 설명</th></tr></thead> FENCE pred, succ</code></td> 메모리 접근 순서 보장 (pred/succ: I, O, R, W의 조합)</td></tr> </tbody></table> 시스템 명령어</h3> 명령어</th> 동작</th> 설명</th></tr></thead> ECALL</code></td> 환경 호출 트랩 발생</td> 시스템 콜 (OS 진입)</td></tr> EBREAK</code></td> 디버그 트랩 발생</td> 브레이크포인트</td></tr> </tbody></table> 과거에는 Zicsr</code>, Zifencei</code> 확장이 RV32I에 포함되어 있었으나, 2.1에서 별도 확장으로 분리되어서 현재는 총 40개의 명령어가 RV32I를 구성하고 있습니다. RISC-V ABI 컨벤션</h2> 레지스터 컨벤션</h3> ISA 수준에서는 강제되지 않지만, 모든 시스템에서 권장되는 레지스터의 사용 컨벤션입니다. x0 = 0</code> 만이 유일하게 ISA에서 강제되는 것이고, 나머지는 하드웨어 관점에서 동등합니다. 실제로 이러한 컨벤션을 준수하는 것은 ABI, Calling Convention의 역할입니다. 하지만, 대부분의 컴파일러, OS, 디버거가 이러한 컨벤션을 준수하고 있기 때문에, 특수한 베어메탈 임베디드에서 외부 라이브러리조차 사용하지 않는 매우 특수한 경우를 제외하고는 이러한 컨벤션을 준수해야합니다. 레지스터</th> ABI 이름</th> 용도</th> Caller/Callee saved</th></tr></thead> x0</code></td> zero</code></td> 항상 0 (ISA 수준에서 고정)</td> —</td></tr> x1</code></td> ra</code></td> 복귀 주소 (Return Address)</td> Caller</td></tr> x2</code></td> sp</code></td> 스택 포인터 (Stack Pointer)</td> Callee</td></tr> x3</code></td> gp</code></td> 전역 포인터 (Global Pointer)</td> —</td></tr> x4</code></td> tp</code></td> 스레드 포인터 (Thread Pointer)</td> —</td></tr> x5</code></td> t0</code></td> 임시 레지스터</td> Caller</td></tr> x6</code></td> t1</code></td> 임시 레지스터</td> Caller</td></tr> x7</code></td> t2</code></td> 임시 레지스터</td> Caller</td></tr> x8</code></td> s0</code> / fp</code></td> 저장 레지스터 / 프레임 포인터</td> Callee</td></tr> x9</code></td> s1</code></td> 저장 레지스터</td> Callee</td></tr> x10</code></td> a0</code></td> 함수 인자 1 / 반환값 1</td> Caller</td></tr> x11</code></td> a1</code></td> 함수 인자 2 / 반환값 2</td> Caller</td></tr> x12</code></td> a2</code></td> 함수 인자 3</td> Caller</td></tr> x13</code></td> a3</code></td> 함수 인자 4</td> Caller</td></tr> x14</code></td> a4</code></td> 함수 인자 5</td> Caller</td></tr> x15</code></td> a5</code></td> 함수 인자 6</td> Caller</td></tr> x16</code></td> a6</code></td> 함수 인자 7</td> Caller</td></tr> x17</code></td> a7</code></td> 함수 인자 8</td> Caller</td></tr> x18</code></td> s2</code></td> 저장 레지스터</td> Callee</td></tr> x19</code></td> s3</code></td> 저장 레지스터</td> Callee</td></tr> x20</code></td> s4</code></td> 저장 레지스터</td> Callee</td></tr> x21</code></td> s5</code></td> 저장 레지스터</td> Callee</td></tr> x22</code></td> s6</code></td> 저장 레지스터</td> Callee</td></tr> x23</code></td> s7</code></td> 저장 레지스터</td> Callee</td></tr> x24</code></td> s8</code></td> 저장 레지스터</td> Callee</td></tr> x25</code></td> s9</code></td> 저장 레지스터</td> Callee</td></tr> x26</code></td> s10</code></td> 저장 레지스터</td> Callee</td></tr> x27</code></td> s11</code></td> 저장 레지스터</td> Callee</td></tr> x28</code></td> t3</code></td> 임시 레지스터</td> Caller</td></tr> x29</code></td> t4</code></td> 임시 레지스터</td> Caller</td></tr> x30</code></td> t5</code></td> 임시 레지스터</td> Caller</td></tr> x31</code></td> t6</code></td> 임시 레지스터</td> Caller</td></tr> </tbody></table> CSED311: Computer Architecture Unknown — Fri, 10 Apr 2026 00:00:00 +0000 포항공과대학교 CSED 311 컴퓨터 구조 수업의 내용을 기반으로 정리한 시리즈입니다. 수업에서 다루지 않은 몇몇 내용을 추가하여 구성하였습니다. B-Tree, B+Tree Unknown — Sun, 26 May 2024 00:00:00 +0000 B-Tree, B+Tree와 자기 균형 이진 트리_{Self-Balanced Binary Tree와의 차이점을 알아본 다음, B-Tree에서 탐색, 삽입, 삭제 과정을 알아보겠습니다.} 이 내용은 포항공과대학교의 CSED 233의 내용을 기반으로 하며, 수업과 차이가 있는 부분은 기울임체로 별도 명시하였습니다. </blockquote> B-Tree</h2> B-Tree는 디스크 상에서 활용될 목적으로 개발된 탐색 트리의 일종입니다. 기본적인 아이디어는 이진 탐색 트리 하나의 노드에 여러 개의 데이터를 저장하는 것인데, 이러면 기본적인 속도는 Red-Black Tree 등 기존 이진 탐색 트리에 비해 느려지지만, 자료의 임의 접근_{Random Access (자료의 주소로 자료를 탐색) 과정과 자기 균형 횟수를 크게 줄일 수 있습니다. HDD나 SSD 등의 디스크 드라이브는 자료의 임의 접근과 쓰기 속도가 굉장히 느린 대신, 순차 접근_{Sequential Access 속도는 비교적 빠르기 때문에 디스크에 저장되는 데이터들을 다루는 DBMS나 File System에서 주로 활용하는 자료구조입니다.}} 디스크 드라이브 이외에도 메인 메모리</a>나 GPGPU</a> 등 cache-conscious indexing이 필요한 다양한 상황에서 B-Tree를 이용할 수 있는 듯 합니다. </blockquote> Probs</h3> 자기 균형 이진 트리와 비교해서는 선술하였듯, 자료의 임의 접근과 자기 균형 횟수를 줄여서 디스크에서 더 효율적이라는 장점이 있습니다. 정렬된 배열_{Sorted Array도 디스크에서 순차 접근이 용이하므로 사용할 수 있지만, B-Tree는 차지하는 디스크 공간이 약간 더 큰 대신 배열보다 업데이트가 빠르고 (전체 배열에서 정렬하는 것보다 트리 노드 내에서 정렬하는 것이 빠르므로) 데이터 탐색이 빠르다는 장점이 있습니다.}B-Tree of order m</h2> m진 탐색 트리는 아래와 같은 조건을 만족해야 합니다. 루트 노드는 최소 2개의 자식 노드를 가집니다.</li> 루트 노드와 리프 노드를 제외한 중간 노드_{internal nodes는 최소 $\lceil x/2 \rceil$ 개의 자식 노드를 가집니다.</li>}모든 리프 노드는 같은 레벨에 있습니다.</li> </ul> 아래는 4진 B-Tree의 예시입니다. 탐색 트리이므로 아래와 같은 조건도 만족합니다. 첫 번째 서브 트리의 키는 첫 번째 키보다 작아야 합니다.</li> N+1 번째 서브 트리의 키는 N 번째 키 이상이고, N+1 번째 키보다 작아야 합니다.</li> 마지막 서브 트리의 키는 마지막 키 이상이어야 합니다. </li> </ul> Analysis</h3> B-Tree의 삽입, 삭제, 검색 연산은 $O(log_m,n)$에 수행할 수 있습니다. 이때 $m$은 트리의 평균 가지 수_{branching factor가 됩니다.} Implementation</h3> B-Tree는 주로 디스크에서 구현한다고 했는데, 보통 한 노드가 하나의 디스크 블록을 차지하게 구현합니다. 여기서 블록은 메인 메모리와 디스크가 주고 받는 데이터의 단위입니다. 수업에서는 파일에 최대로 할당할 수 있는 연속적인 디스크 공간 이라고 설명했습니다. 디스크의 데이터는 블록 단위로 한 번에 메모리로 불러 들여올 수 있기 때문에, 블록 단위로 노드를 구성하는 것이 가장 적합합니다. B+Tree</h2> B+Tree는 B-Tree와 비슷하되, 실제 데이터는 리프노드에만 저장하고, 루트노드와 중간노드에는 키만 저장하는 방식입니다. 데이터가 리프노드에만 저장되기 때문에 중복된 키도 허용됩니다. 추가로, 각 리프노드에 형제노드_{Sibling으로 가는 포인터를 주어 모든 데이터를 순회하는 것을 효율적으로 만듭니다.} B-Tree와 비교해서 메모리 사용량과 요구 디스크 공간이 약간 커지는 단점이 있으나, 데이터의 순차 검색 성능이 매우 좋아집니다. NTFS, XFS, JFS2 FileSystem과 MySQL 등 관계형 데이터베이스 테이블의 인덱싱에 B+Tree를 이용합니다 </blockquote> B*Tree</h3> B*Tree는 노드의 생성 최소화를 위하여 B+Tree에서 몇 가지의 제약 조건을 추가한 자료구조입니다. 자식 노드 수의 최소 개수는 $\lceil 2M/3 \rceil$개로 늘어나고, 노드가 가득 차면 노드 분할을 진행하는 B+Tree와 달리 형제 노드로 재배치를 우선적으로 진행합니다. 2-3 Tree</h2> 2-3 Tree는 B-Tree의 특수한 경우입니다. 3진 트리로서 모든 중간노드가 2~3개의 자식노드를 가지며, 마찬가지로 모든 리프노드는 같은 레벨에 정렬됩니다. 실제로 자주 쓰이는 형태는 아니지만, 2-3 Tree의 경우 B-Tree의 기본 연산들을 설명하기 쉽기 때문에 이런 형태를 가정합니다. B-Tree로도 2-3 Tree를 구현할 수 있지만, B+Tree의 형태로 2-3 Tree를 구현한다고 생각하고 아래 설명을 진행하겠습니다. Search</h3> 탐색은 이진 탐색 트리와 유사하게 하면 됩니다. 2개의 노드와 키 값을 비교하여 왼쪽 자식노드, 중간 자식노드, 오른쪽 자식노드 중 하나를 선택하면서 내려가는 과정을 반복하면 됩니다. 시간 복잡도는 $O(log_3,n)$ 입니다. Insert</h3> 삽입은 우선 데이터가 들어갈 노드를 찾는 것으로 시작합니다. 이때 노드에 빈 공간이 있는 경우와 없는 경우로 구분할 수 있는데, 노드에 빈 공간이 있는 경우는 그냥 그 자리에 데이터를 넣으면 됩니다. 노드에 빈 공간이 없는 경우에는 새로운 노드를 만들어 데이터를 삽입한 다음 균형을 맞춥니다. Delete</h3> 제거도 우선 데이터가 있는 노드를 찾는 것으로 시작합니다. 이때는 노드에 자식이 3개 있는 경우와 2개 밖에 없는 경우로 나누게 되는데, 3개 있는 경우는 그냥 없애면 되지만, 2개 있는 경우는 하나를 삭제해 버리면 B-Tree의 구조 조건 중 하나인 최소 $\lceil x/2 \rceil$ 개의 자식 노드 (2-3 Tree에서는 2개)를 충족하지 못하게 됩니다. 따라서 이 경우 형제노드의 남는 데이터를 끌어오거나 (형제노드의 자식이 3개인 경우) 값을 형재노드로 재위치시킨 후, 노드를 삭제하는 방법으로 데이터를 삭제합니다. (형제노드의 자식이 2개인 경우) Reference</h2> POSTECH CSED 233 : Data Structure</li> https://www.quora.com/Why-is-BTree-used-in-DBMS-not-BST-or-AVL</a></li> https://yeongjaekong.tistory.com/38</a></li> https://ko.wikipedia.org/wiki/B%2B_%ED%8A%B8%EB%A6%AC</a></li> https://www.quora.com/When-duplicate-keys-are-allowed-in-a-B-tree-what-are-the-changes-of-some-algorithms-when-compared-to-the-B-tree-with-no-duplicate-keys</a></li> </ul> CSED233: Data Structure Unknown — Sun, 26 May 2024 00:00:00 +0000 포항공과대학교 CSED 233 자료구조 수업의 내용을 기반으로 정리한 시리즈입니다. 딕셔너리와 맵, 해싱 Unknown — Sat, 25 May 2024 00:00:00 +0000 본 글에서는 딕셔너리와 해싱을 알아보고, 각 언어의 구현을 알아보며 배운 내용을 체크해보려 합니다. 이 내용은 포항공과대학교의 CSED 233의 내용을 기반으로 하며, 수업에서 다루지 않은 내용은 인용문으로 표기하였거나 별도 명시하였으니 참고바랍니다. </blockquote> Dictionary ADT</h2> 딕셔너리는 추상 자료형_{Abstract Data Types의 일종으로, 특정 키에 대해 특정 원소가 매핑되는 짝의 집합으로 구성되어 있습니다.} 구현마다 다르긴 합니다만 대체로 중복키는 허용되지 않습니다.</li> </ul> Map이라고도 불립니다. 다만 Map과 Dictionary를 다르게 정의하는 경우도 가끔 있습니다. </blockquote> Fundamental Operations</h3> x = (k : key, d : data)</li> Insert(x, D) : 삽입 연산</li> Delete(k, D) : 제거 연산</li> Search(k, D) : 조회_{Lookup 연산</li> </ul> 딕셔너리는 무순사전_{Unordered Dictionary과 순서 사전_{Ordered Dictionary으로 구분됩니다. 무순사전은 요소를 임의의 순서로 집합에 추가하고, 순서사전은 요소를 key를 기준으로 하여 특정한 순서로 집합에 추가합니다. 많은 언어는 이 두 종류의 딕셔너리를 모두 구현체에 포함하고 있습니다. </blockquote>}} Dictionary Implementations</h2> 딕셔너리를 구현하는 방법은 리스트, 해싱, 트리 세가지로 나눌 수 있습니다. 각각의 구현이 key를 찾는 방법과 시간 복잡도는 아래와 같습니다. Unsorted List : 리스트를 처음부터 끝까지 순회하며 key를 찾습니다 : $O(n)$</li> Sorted List : 이진 탐색을 이용하여 key를 찾습니다 : $O(log,n)$</li> Hash Table : key의 해시값을 이용하여 데이터에 직접 접근합니다 : 최악 $O(n)$, 평균 $O(1)$</li> Binary Search Tree : 이진 탐색 트리를 이용하여 key를 정렬한 다음 찾습니다 : 최악 $O(n)$, 평균 $O(log,n)$</li> Self-Balanced Binary Search Tree : AVL Tree나 Red-Black Tree 등으로 구현된 자기 균형 이진 탐색 트리에서는 : $O(log,n)$</li> </ul> Unsorted List는 Python의 OrderedDict</code> 구현에 사용되고, (Doubled Linked List를 이용해 들어간 순으로 정렬됩니다.) Binary Search Tree는 C++의 map</code>, Rust의 BTreeMap</code> 구현에 사용됩니다. 이 글에서는 Hash Table 구현 위주로 설명하며, 다른 구현은 다루지 않습니다. </blockquote> Hashing</h2> 해싱을 이용해서 키를 해시 테이블의 특정 위치에 매핑합니다. 생각해봐야 할 점 어떤 해시 함수를 사용할 것인가?</li> 충돌을 어떻게 해결할 것인가?</li> 해시 테이블의 크기는 어떻게 할 것인가?</li> 해시 테이블이 꽉 차면 어떻게 할 것인가?</li> </ul> Hash Function</h2> 해시 함수는 충돌을 최소화하고, 계산이 빨리 끝나는 것이 좋은 해시함수가 됩니다. 해시 테이블의 사용에서 대부분의 경우 들어오는 키가 밀집되어_{highly clusted 있기 때문에, 이를 분산하는 것은 해시 함수의 중요한 역할입니다.} 우선 해시 함수는 키가 정수가 아닌 경우 특정 정수로 변환하고, 정수를 해시 테이블의 범위의 맞는 수로 변환하여 분산시킵니다. Division</h3> int hash(int x) { return(x % M); }</code></pre> 정수를 해시 테이블의 크기 M으로 나누면 해시된 값이 항상 해시 테이블 내부에 있음을 보장할 수 있습니다. Choice of M</h4> 만약 Divisor M이 짝수 값이라면, Hash Table 상의 가능한 모든 해시값을 만들 수 없습니다. 따라서 짝수 값 M을 사용해서는 안됩니다. 만약 m=6이고 들어오는 값이 모두 짝수일 때 : 0 => 0 2 => 2 4 => 4 6 => 0 8 => 2...</code></pre> 홀수 M에서는 그런 문제가 덜 발생하나, 여전히 같은 문제로 해시 테이블이 낭비될 가능성이 있습니다. 만약 m=9=3*3이고 들어오는 값이 모두 3의 배수일 때 : 3 => 3 6 => 6 9 => 0 12 => 3 15 => 6...</code></pre> 따라서, 작은 소인수가 없는 임의의 수나 소수로 M을 선정하는 것이 가장 적합합니다. 예를 들면, 713=23 * 31은 들어오는 값이 23의 배수, 31의 배수가 아닌 경우 균일한 해시 값을 냅니다. 23의 배수, 31의 배수인 경우는 2의 배수, 3의 배수인 경우보다 훨씬 드문 경우이므로 나쁘지 않은 M 값이라고 할 수 있겠습니다. String Folding</h3> int hash(string x) { int i, sum; for(char c : x) { sum += (int)c; } return sum % M; }</code></pre> 만약 들어오는 값이 정수가 아닌 문자열인 경우 문자열을 접어서_{Folding 특정 정수로 만들 수 있습니다.} Mid-Square</h3> 키 값을 제곱하여 중간 자리 숫자만을 선택하여 해시 테이블의 인덱스로 사용하는 방식입니다. 제곱 결과는 키 값의 모든 자릿수의 영향을 받기 때문에, 키 값이 밀집되어 있더라도 분산된 해시 결과 값을 낼 확률이 높습니다. 십진수로 예를 들겠습니다. 4567을 제곱하면 20857489가 되는데, 이 중 중간 2자리인 57</code>을 인덱스로 사용한다고 해봅시다. 이때 4568을 제곱하면 20866624가 되는데, 인덱스는 66</code>이 됩니다. 키 값은 한 자리 차이이나 해시값은 전혀 다르게 나온 것을 알 수 있습니다. 보통은 2진수 값을 사용하기 때문에 중간 r비트를 추출하여 0~$2^r-1$ 사이의 값이 나오게 됩니다. Types of Hashing</h2> Static Hashing</h3> 정적 해싱_{Static Hashing은 해시 테이블의 크기를 고정하여 해싱하는 방법입니다. 충돌하는 키를 다루는 방법에 따라 다시 Open Hashing이나 Closed Hashing으로 나뉘게 됩니다. 데이터의 사이즈가 커질수록 성능이 크게 감소하는 단점이 있습니다.} Open Hashing</h4> 오픈 해싱 (Seperate Chaning이라고도 불림)은 충돌이 발생할 경우 연결 리스트 등을 이용해 여러 개의 키-데이터를 해시 테이블 인덱스 하나에 보관하는 방법입니다. 충돌이 다수 발생하여 하나의 인덱스에 너무 많은 데이터가 보관될 경우 조회가 느려지게 됩니다. Closed Hashing</h4> 폐쇄 해싱은 오픈 해싱과 다르게 충돌을 피하고 하나의 해시 테이블 인덱스에는 하나의 값만 보관하는 방법입니다. Bucket Hashing과 Rehashing 두가지 방법이 있습니다. 폐쇄해싱의 경우 충돌이 발생하면 데이터를 원래 있어야 할 곳이 아닌 다른 곳에 보관하기 때문에, 데이터를 삭제할 경우 삭제되었다는 흔적을 남겨주어야 충돌해서 다른 곳에 가버린 데이터를 검색할 수 있습니다. Bucket Hashing</h5> 해시 테이블의 슬롯을 일정 크기의 버킷으로 나누어서 (즉, 하나의 해시 값에 여러 인덱스를 할당하여) 충돌이 발생하여도 다음 인덱스를 채우는 방법입니다. 이 방법을 사용하여도 버킷이 가득 차면 오버플로우가 발생하게 되는데, 슬롯이 가득 찬 인덱스를 검색하는 Overflow Bucket을 따로 만들어서 문제를 해결할 수 있습니다. 마찬가지로 충돌이 발생할 경우 점점 속도가 느려지며, 특히 Overflow Bucket은 $O(n)$으로 검색되기 때문에 오버플로우가 자주 발생할 경우 조회가 느려지게 됩니다. Rehashing</h5> 충돌이 발생하면 다시 해싱하는 방법입니다. Open Addressing이라고도 불립니다. 원래 키 값에 Probe 함수의 값을 더해서 다른 인덱스를 만들어내게 됩니다. Linear Probing: 충돌이 발생할 때마다 키 값을 1씩 증가시킵니다. 이 경우 들어오는 키 값이 밀집되어 있는 경우 1차 군집화_{Primary Clustering 문제가 발생하여 비어있는 공간의 탐색에 시간이 오래 걸리게 됩니다. (5, 6, 7, 8 키가 이미 들어간 상태에서 4가 들어간다고 생각해보면 4, 5, 6, 7, 8, 9을 모두 해싱해보아야 빈 공간을 찾을 수 있을 것입니다.)</li>} Pseudo-Random Probing : 충돌이 발생할 때 마다 키 값을 임의의 순열 값으로 증가시킵니다. 보통 Shift-Register Sequence가 사용되는데, 충돌이 발생할 때 마다 키 값을 Shift하고 (2배 하고) 특정 값과 XOR하는 방법입니다.</li> Quadratic Probing : 임의의 다항식을 이용하여 키 값을 증가시킵니다. 보통 제곱 값을 이용해서 k+1, k+4, k+9... 순으로 찾게 됩니다.</li> </ul> Secondary Clustering : 2차 군집화는 Pseudo-Random이나 Quadratic 프로빙을 이용하더라도 초기 해시값이 같은 키의 경우 다음 해시값도 계속 일치하는 문제입니다. 이 경우 동일한 해시 값을 가진 키가 여러 번 들어오면 점점 조회가 느려지게 됩니다. Double Hashing : 이 경우 이중 해싱을 이용해서 문제를 해결합니다. 탐색을 위해 서로 다른 두개의 해시 함수를 이용하는 방법입니다.</li> </ul> Dynamic Hashing</h3> 동적 해싱_{Dynamic Hashing은 데이터의 증가에 따라 해시 테이블의 크기를 늘려 해싱하는 방법입니다. 수업에서는 다루지 않았습니다. 데이터 증감에 따라서 해시함수가 동적으로 변환되며, 해시테이블 버킷의 수가 고정되지 않고 필요할 때마다 늘거나 줄어듭니다. 주로 다루는 데이터 크기가 매우 큰 DBMS에서 이런 방식을 사용합니다.} Extendible Hashing</h4> 확장성 해싱은 동적 해싱에서 가장 많이 사용하는 방법으로, 이중구조로 딕셔너리를 만드는 방법입니다. 키를 비트 스트링으로 변환하고, 비트 스트링의 처음 몇 비트를 디렉토리라는 배열의 인덱스로 사용합니다. 디렉토리는 다시 버킷들의 포인터를 가지는데, 이 버킷에 데이터를 저장합니다. 만약 버킷에 오버플로우가 발생하면 버킷을 분할하여 공간을 늘립니다. 데이터의 크기가 커지더라도 디스크 접근 횟수가 늘어나지 않으나, 데이터의 숫자가 적을 경우 오히려 비효율적이라는 단점이 있습니다. HashMap Implementation</h2> 각 언어의 해시맵 구현 방법을 알아보겠습니다. 마찬가지로 수업에서는 다루지 않았습니다. C++ : unordered_map</h3> C++의 해시맵인 unordered_map은 우선 기본적인 Division Hashing을 이용하여 Linked List 버킷에 데이터를 저장합니다. 이때 load_factor</code>라는 값이 변경되는데, 이는 입력된 데이터의 개수 / 버킷의 총 개수</code>를 의미합니다. 만약 이 load_factor</code>가 max_load_factor</code> (기본적으로 1.0)를 넘어서면 전체 버킷의 개수를 증가시키고, 전체 데이터를 새로운 bucket_count</code>로 재해싱합니다. 이때 어떤 값으로 bucket_count</code>를 증가시킬지는 Undefined Behavior입니다. 각 컴파일러마다 다른 값을 사용하는데, GCC와 Clang은 소수를, MSVC는 2의 제곱에서 1을 뺀 값을 이용한다고 합니다. 아래 프로그램을 통해 대략적인 구조를 확인해볼 수 있습니다. int main() { unordered_map<int, int> map; std::cout << map.bucket_count() << std::endl; for(int i = 30; i > 0; i--) { map.insert(make_pair(i, 1)); std::cout << map.bucket_count() << std::endl; for(auto& x : map) { cout << "(" << x.first << ", " << x.second << ")"; cout << " is in bucket= " << map.bucket(x.first) << endl; } } }</code></pre> 모듈로 연산만을 이용하기 때문에, C++의 unordered_map은 저격 데이터를 만들기가 쉽다는 문제가 있습니다.</a> Python : Dictionary</h3> 파이썬은 딕셔너리가 표준 라이브러리가 아닌 언어의 기본 기능으로 내장되어 있는데, Rehashing, 그중에서도 Linear Probing을 기본적으로 사용하고, 그 외에는 C++의 구현과 비슷하게 load_factor를 이용하여 일정 수준 이상일 경우 해시테이블의 크기를 증가시킵니다. 다만 Linear Probing은 Primary Clustrering에 매우 취약하기 때문에, 기본 load_factor가 1.0인 C++과 다르게 0.75를 기본 값으로 사용한다고 합니다. 앞서 C++은 저격 데이터를 만들기가 상당히 쉽다고 말했는데, 이렇게 저격 데이터를 만들어서 해시맵의 용량과 CPU 사용량을 늘리는 것을 HashDoS 공격이라고 합니다. HashDoS 공격을 당한 서버는 갑자기 프로세서 사용량이 폭증하여 요청을 정상적으로 처리할 수 없게 됩니다. 따라서 Python은 3.4 정도 버전부터 HashDoS 공격을 방어하기 위해 SipHash</a> 알고리즘을 이용합니다. 자세한 내용은 여기서 설명하지 않겠지만, 임의의 난수를 통해 데이터를 해싱하여 임의로 해시값을 중복시키는 것을 어렵게 만드는 알고리즘입니다. Pseudo-Random Hashing의 일종으로 보면 될 것 같습니다. Rust : HashMap</h3> Rust도 기본적으로 SipHash</a> 알고리즘을 이용합니다. 해시 테이블의 구현은 SwissTable</a>의 Rust 포팅 버전을 이용하는데, 마찬가지로 많이 복잡하여 자세한 내용은 설명하지 않지만, SIMD를 활용하여 최적화한 Open Addressing 해시 테이블이라고 생각하면 될 듯 합니다. Reference</h2> POSTECH: CSED 233 Data Structure</a></li> https://skyil.tistory.com/117</a></li> https://stackoverflow.com/questions/34496582/is-ordereddict-a-tree</a></li> https://stackoverflow.com/questions/9456790/why-are-composite-numbers-bad-for-hashing-by-division</a></li> https://m.blog.naver.com/beaqon/221300416700</a></li> https://growth-coder.tistory.com/16</a></li> https://stackoverflow.com/questions/31112852/how-stdunordered-map-is-implemented</a></li> https://charsyam.wordpress.com/2018/02/04/%EC%9E%85-%EA%B0%9C%EB%B0%9C-siphash%EC%9D%98-%EC%82%AC%EC%9A%A9-data-ddos%EB%A5%BC-%EB%B0%A9%EC%A7%80%ED%95%B4%EB%B3%BC%EA%B9%8C/</a></li> https://doc.rust-lang.org/std/collections/struct.HashMap.html</a></li> https://faultlore.com/blah/hashbrown-tldr/</a></li> </ul>} 트리 리루팅 (전방향 트리 DP) Unknown — Fri, 12 Apr 2024 00:00:00 +0000 엣코더 ABC #348</a>의 E - Minimize Sum of Distance</a> 에서 트리 DP, 그중에서도 전방향 트리(全方位木（</rp>ぜんほういき</rt>）</rp></ruby>) DP를 쓴다고 해서 찾아봤습니다. 이 알고리즘은 일본 외에서는 Rerooting 이라고 불리며, 루트가 정해지지 않은 트리에서 조건에 맞는 루트를 구할 때 유용하게 사용할 수 있는 테크닉입니다. 한국에서는 트리에서의 다이나믹 프로그래밍 분류의 일종으로 취급되지만, 외국에서는 이름을 따 붙힐 정도로 경쟁적 프로그래밍에서 은근 자주 출제되는 알고리즘인 듯 합니다. 개념</h2> 트리 DFS</h3> 우선 특정 노드에 대해서 다른 노드까지 가는 간선 비용의 총합을 구하는 방법을 생각해 봅시다. 이는 DFS+DP를 통해 $O(n)$으로 구현할 수 있습니다. 리루팅</h3> 그렇다면 다른 노드까지 가는 간선 비용의 총합이 가장 작은 노드는 어떻게 구할 수 있을까요? 위에 설명한 트리 DFS를 노드의 개수만큼 사용하면 되겠지만, 그렇다면 $O(n^2)$이 소요되어 정점이 $10^5$개만 넘어가면 시간초과가 날 것입니다. 바로 이때 리루팅 테크닉을 사용합니다. DFS+DP트리의 루트를 옮기는 것은 $O(1)$에 가능하다는 것을 이용하는 테크닉입니다. 위 그림에서, A노드의 총 거리합인 30을 이용해서 B노드의 총 거리합을 구해봅시다. A노드와 그 너머에 있는 A(0), C(3), F(7) 노드의 거리는 A-B 간선의 비용 5만큼 증가해서, A(5), C(8), F(12)가 될 것이고, B노드와 그 아래에 있는 B(5), D(8), E(7) 노드의 거리는 A-B 간선의 비용 5만큼 감소해서 B(0), D(3), E(2)가 될 것입니다. A노드의 증가분과 B노드의 감소분은 서로 상쇄되니까 즉, (A의 총 거리합) - {(A노드 너머 노드 수) - (B노드 아래 노드 수)} * (A-B 간선의 비용)}</code>이 B노드의 총 거리합이 되는 거죠. 이 방법을 이용해서 A노드의 총 거리합을 알 때, B노드의 총 거리합을 $O(1)$에 구할 수 있습니다. 이 테크닉을 루트를 옮기다고 생각하면 리루팅 테크닉이고, 양방향으로 검색하며 DFS를 돌린다고 생각하면 전방향트리 DP라는 이름이 됩니다. 알고리즘이 대부분 그렇듯 이름은 별로 중요하지 않습니다. 여기서 A노드 너머 노드 수와 B노드 아래 노드 수는 A의 총 거리합을 구하는 첫 DFS를 할 때, 서브노드의 개수를 함께 저장해두면 구할 수 있습니다. 위의 예시로 들면, A의 서브노드 개수</code> - B의 서브노드 개수</code>가 A 너머의 노드 수가 되겠고, B의 서브노드 개수</code>가 그대로 B노드 아래 노드 수가 되겠네요. 예제</h2> BOJ 27730 : 견우와 직녀</a></h3> 위 예제를 그대로 적용할 수 있는 문제입니다. 트리 두 개에 대해서 시행하고, 양 쪽에서 거리합이 가장 작은 노드를 출력하면 됩니다. BOJ 7812 : 중앙 트리</a></h3> 중앙 노드를 리루팅을 이용해 구한 다음, 다시 DFS를 돌려서 모든 노드에서의 거리를 출력하면 됩니다. ABC#348 E</a></h3> 제가 리루팅 테크닉이라는 이름을 처음 알게 된 문제인데, 간선의 비용이 아닌 정점의 비용이 주어집니다. 즉, (해당 정점으로 가는데 필요한 간선 수) * (정점의 비용)</code>이 간선의 비용이 됩니다. 이 문제는 정점의 비용 합 c[x]</code>와 거리 합c[x]*d</code>를 모두 기억하면서 해결하면 됩니다. 정리한 정해 코드는 아래와 같고, 해설은 에디토리얼</a>이 있으니 참조해 주세요. #include <bits/stdc++.h> using namespace std; #define llint long long int int main() { int n; cin >> n; vector<int> a(n - 1), b(n - 1); vector<vector<int>> tree(n); for (int i = 0; i < n - 1; i++) { cin >> a[i] >> b[i]; a[i] -= 1; b[i] -= 1; tree[a[i]].push_back(b[i]); tree[b[i]].push_back(a[i]); } vector<llint> c(n); for (int i = 0; i < n; i++) cin >> c[i]; //sum_c[i]는 루트를 i로 하는 트리에 대해 정점 c[x]의 합 //sum_d[i]는 루트를 i로 하는 트리에 대해 c[x] * d(i, x)의 합 vector<llint> sub_sum_c(n), sub_sum_d(n); auto dfs =[&](auto &&self, int v, int par) -> pair<llint, llint> { //v: 현재 노드, par: 부모 노드 for (int t: tree[v]) { //모든 하위방향 노드들에 대해 if (t == par) continue; //부모 방향으로는 가지 않는다 auto [child_sum_c, child_sum_d] = self(self, t, v); sub_sum_c[v] += child_sum_c; //하위방향 c를 누적 sub_sum_d[v] += child_sum_d; //하위방향 d를 누적 } sub_sum_d[v] += sub_sum_c[v]; //재귀적으로 c[x]가 d(i, x)번 합해진다 sub_sum_c[v] += c[v]; return {sub_sum_c[v], sub_sum_d[v]}; }; dfs(dfs, 0, -1); //루트에서부터 dfs, 0(1)번 노드를 루트로 취급 //dfs를 통해 모든 노드에 대해 f(n)을 구합니다. vector<llint> f(n); auto reroot =[&](auto &&self, int v, int par, llint par_sum_c, llint par_sum_d) -> void { //v: 현재 노드, par: 부모 노드, par_sum_c: 상위방향으로의 c합, par_sum_d: 상위방향으로의 d합 f[v] = sub_sum_d[v] + par_sum_d; for(int t : tree[v]) { //모든 하위방향 노드들에 대해 if(t == par) continue; //부모 방향으로는 가지 않는다 llint nc = par_sum_c //v의 상위방향으로의 c 합 + sub_sum_c[v] //v의 하위방향으로의 c합 //여기까지 모든 노드의 c합 - sub_sum_c[t]; //t의 하위방향으로의 c합 뺀다 //nc : t의 상위방향으로의 c합 llint nd = par_sum_d //v의 상위 방향으로의 d합 + sub_sum_d[v] //v의 하위방향으로의 d합 - sub_sum_d[t] - sub_sum_c[t] //t의 양방향 d합을 뺸다 //여기까지 t가 v위치에 있었을 때 sum_d + nc; //t의 상위방향으로의 c합 //nd : t의 상위방향으로의 d합 self(self, t, v, nc, nd); } }; reroot(reroot, 0, -1, 0, 0); cout << *min_element(f.begin(), f.end()) << endl; }</code></pre>도보시오</h2> Codeforces - Rerooting Technique</a></li> nicotina04 - Rerooting Tequnique on Tree</a></li> Codeforces - Online Query Based Rerooting Technique</a></li> </ul> Docker를 이용한 리눅스 실습 환경 구축 Unknown — Tue, 29 Aug 2023 00:00:00 +0000 동아리에서 후배들에게 리눅스 세미나를 하게 되었습니다. 그러면 실습 환경 구축을 해야겠죠. 제작년에는 선배들이 버추얼 박스를 설치해 오라고 시켰고, 작년에는 똑같이 제가 세미나를 맡아서 후배들에게 제 리눅스 서버 계정을 하나씩 넘겨주는 방식으로 실습을 했는데요, 올해는 제 리눅스랑 가상화 지식이 많이 늘기도 했고, 서버도 깔끔하게 재구축했으니</a> 가상화를 통해 1인 1서버를 주는 걸 만들어보기로 했습니다. 구글링</h3> 원래는 컨테이너를 여러개 열어서 SSH 리버스 프록시나 점프 포워드로 구축해 보려고 했는데, 생각보다 어려워서 고전하던 중, 아래 글을 발견하게 되었습니다. Replicate and Isolationg user environments on the fly</a> 제가 딱 원하던거여서, 이 내용을 기반으로 환경에 맞게 수정해서 구축하기로 했습니다. 이미지 만들기</h3> 위 글에서는 컨테이너를 수정하고 그걸 다시 이미지로 만드는 과정을 거쳤는데, 그건 너무 귀찮아서 Dockerfile로 구성하기로 했습니다. # Dockerfile FROM ubuntu:latest RUN apt-get update RUN apt-get install -y vim sudo man-db gcc RUN yes | unminimize RUN useradd -ms /bin/bash guest RUN echo 'guest:password' | chpasswd RUN usermod -a -G sudo guest USER guest WORKDIR /home/guest</code></pre> 실습에 필요한 패키지인 vim</code>, sudo</code>, man-db</code>, gcc</code> 를 깔고, unminimize</code>를 수행해서 man</code>이 동작하게 만듭니다. 그리고 guest 라는 유저를 만들어서 컨테이너에 접속하게 되면 루트가 아니라 유저로서 접속하게 합니다. 이러면 ssh로 직접 접속하는거랑 더 비슷한 느낌을 줄 수 있겠죠. docker build --tag sandbox .</code></pre> 로 이미지를 빌드합니다. 유저 만들기</h3> 이제 유저를 만들어서, SSH로 접속하게 되면 가짜 셸에 접속하게 합니다. mkdir /home/guest cat > /home/guest/sandbox <<EOF #!/bin/sh exec docker run -t -i --rm=true sandbox /bin/bash EOF chmod +x /home/guest/sandbox # useradd guest -g docker -s /home/guest/sandbox useradd guest -s /home/guest/sandbox chown guest /home/guest passwd guest</code></pre> 저는 Docker가 아니라 Podman 환경이어서, 유저에게 docker</code> 그룹을 주지 않아도 Rootless Podman</a>을 실행할 수 있었습니다. Docker로 구성할 경우 docker</code> 그룹을 주는게 필요하겠네요. docker</code> 명령어에는 --rm=true</code> 인자를 붙혀서 도커 컨테이너에서 나갈 경우 바로 컨테이너가 삭제되도록 하고, 유저가 들어오면 가짜 셸을 실행해서 도커를 열게 합니다. 완성</h3> 위 설정대로 구축하고, guest</code>유저로 ssh 접속하게 되면 임시 생성된 컨테이너에 가둬지게 됩니다. (블로그에 쓴 것과 유저 이름은 다릅니다.) 이 환경에서는 원하는 만큼 패키지를 설치하거나 (커널에 관련된 것만 아니면) 시스템을 수정할 수 있고, sudo rm -rf /</code>를 수행해도 컨테이너를 실행하는 시스템에는 아무런 영향이 가지 않습니다. 나왔다 들어오면 모든 내용이 초기화되고 새 컨테이너를 생성하니 실습하기 좋은 환경이죠. sudo rm -rf --no-preserve-root /</code></pre> 을 실행해보고 시스템이 박살나지 않는지 확인해 봅시다. 2024.07.15 추가</h3> 위와 같이 컨테이너를 구축하면 로그아웃 할 때 가끔 컨테이너가 제대로 지워지지 않는 문제, 로그인 할 시에 Refreshing Error가 발생하는 문제가 있습니다. ERRO[0001] Refreshing container 2e3d121a75ec00add6a35694cdc26e6442bb98a7e993b918569dd7584597bca6: acquiring lock 0 for container 2e3d121a75ec00add6a35694cdc26e6442bb98a7e993b918569dd7584597bca6: file exists</code></pre> 로그아웃 할 때 컨테이너가 지워지지 않는 문제는 guest</code> 계정의 .bash_logout</code> 파일에 docker stop sandbox</code>를 적었는데, 일단 확실하진 않지만 해결이 된 것 같고, 에러는 loginctl enable-linger guest</code>를 통해 계정의 lingering mode를 허용해 주면 해결되는 듯 합니다. 순차탐색과 이분탐색 Unknown — Mon, 01 Nov 2021 00:00:00 +0000 !! 구 블로그 (Blogger) 에서 가져온 글입니다. 글 일부가 깨져보일 수 있습니다. </blockquote> 탐색이란?</h2> 탐색이란 데이터 구조 안의 저장된 정보를 찾는 것입니다. 대표적인 탐색 알고리즘에는 3가지가 있습니다. 순차탐색 (Sequential Search) — 혹은 선형탐색 (Linear Search)</li> 이분탐색 (Binary Search)</li> 해시탐색 (Hash Search)</li> </ul> 이 글에서는 순차탐색과 이분탐색만을 다룹니다. 해시탐색은 언젠가 다룰 예정... +: 3년이라는 시간이 걸렸지만 다뤘습니다. 딕셔너리와 맵, 해싱</a> 순차탐색 (Sequential Search)</h3> 순차탐색은 탐색알고리즘 중 가장 간단한 형태의 알고리즘이며, 선형탐색 (Linear Search) 라고도 합니다. 어떠한 데이터 배열이 있으면 데이터 배열의 처음부터 끝까지 모두 비교하여 자료를 찾아냅니다. 쉽게 말해서 그냥 배열 처음부터 끝까지 노가다. 장점 정렬되지 않은 배열에서 사용할 수 있다.</li> 구현이 간편하다.</li> </ul> 단점 데이터의 양이 많아지면 비효율적이다.</li> </ul> 순차탐색의 코드는 아래와 같습니다. #include <stdio.h> #define SIZE_OF_ARRAY 10 int array[SIZE_OF_ARRAY]; int main() { /*array를 입력받는 코드 (전역변수이므로 초기값 0)*/ int x; //x:배열에서 찾을 값 scanf("%d",&x); int i; //i:인덱스 for(i = 0; i<SIZE_OF_ARRAY; i++) { if(array[i] == x) printf("%d",i); //만약 array에서 x값을 찾으면 인덱스 값 출력 } }</code></pre> 위의 내용을 함수로 만든 코드 스니펫 (클릭)</summary> int SequentialSearch(int* array, int n, int x) //arr:배열포인터, n:배열의 길이, x:찾을 값 { for(i = 0; i<n; i++) { if(array[i]==x) return i; //만약 x를 찾으면 인덱스를 반환 } return -1; //찾지 못했으면 -1을 반환 }</code></pre></details> 이분탐색 (Binary Search)</h3> 이분탐색은 정렬된 데이터에서 쓸 수 있는 탐색 알고리즘으로, 찾고자 하는 값을 가운데 값과 비교해서 그 값이 왼쪽에 있는지 오른쪽에 있는지 파악하여 자료를 찾습니다. 장점 순차탐색에 비해 탐색속도가 빠르다.</li> </ul> 단점 데이터가 미리 정렬되어 있어야 한다.</li> 데이터의 임의접근(Random Access)이 가능해야한다. — 데이터에 몇개의 요소가 있는지에 관계없이, 모든 요소에 대해 같은 시간 내에 접근 할 수 있는 접근 방식, C언어의 배열은 임의접근이 가능하며, 연결리스트와 같은 특정 자료구조는 불가능하다. (어렵다면 지금은 무시해도 좋다.)</li> </ul> 이분탐색의 대략적인 의사코드는 다음과 같습니다. 배열의 중앙값과 찾으려는 값을 비교한다.</li> 만약 찾으려는 값이 더 작다면 왼쪽 부분, 더 크다면 오른쪽 부분을 선택한다. 같다면 탐색을 종료한다.</li> 선택한 구간의 중앙값과 찾으려는 값을 비교한다. -> B로 돌아간다.</li> </ol> 이분탐색은 재귀함수와 반복문, 두 가지 방법으로 구현할 수 있습니다. 이분탐색의 반복문 구현 #include <stdio.h> #define SIZE_OF_ARRAY 10 int array[SIZE_OF_ARRAY] int main() { /*array를 입력받는 코드 (전역변수이므로 초기값 0)*/ int x; //x:배열에서 찾을 값 scanf("%d",&x); int left=0, right=SIZE_OF_ARRAY-1, mid; while(left<=right) //left가 right 이하 일때 반복 { mid=(left+right)/2; if(array[mid]==x) printf("%d",mid); //찾으면 index 출력 else if(array[mid] > x) right=mid-1; else if(array[mid] < x) left=mid+1; } printf("Not Found\n"); //찾지 못할 경우 출력 }</code></pre> 위의 내용을 함수로 만든 코드 스니펫 (클릭)</summary> int BinarySearch(int* array, int n, int x) //arr:배열포인터, n:배열의 길이, x:찾을 값 { int left=0, right=n-1, mid; while(left<=right) //left가 right 이하 일때 반복 { mid=(left+right)/2; if(array[mid]==x) return mid; else if(array[mid] > x) right=mid-1; else if(array[mid] < x) left=mid+1; } return -1; }</code></pre></details> 이분탐색의 재귀함수 구현 #include <stdio.h> #define SIZE_OF_ARRAY 10 int array[SIZE_OF_ARRAY] int RecursiveBinarySearch(int left, int right, int x) { int mid; if(left>right) return -1; mid = (left+right)/2; if(x==array[mid]) return mid; else if(array[mid]>x) return RecursiveBinarySearch(left, mid-1, x); else if(array[mid]<x) return RecursiveBinarySearch(mid+1, right, x); } int main() { /*array를 입력받는 코드 (전역변수이므로 초기값 0)*/ int x; //x:배열에서 찾을 값 scanf("%d",&x); printf("%d",RecursiveBinarySearch(0,SIZE_OF_ARRAY,x)); }</code></pre> 위의 내용을 함수로 만든 코드 스니펫 (클릭)</summary> int BinarySearch(int* array, int n, int x) //arr:배열포인터, n:배열의 길이, x:찾을 값 { int mid; if(left>right) return -1; mid = (left+right)/2; if(x==array[mid]) return mid; else if(array[mid]>x) return BinarySearch(left, mid-1, x); else if(array[mid]<x) return BinarySearch(mid+1, right, x); }</code></pre></details>

Analysis</h3>
B-Tree의 삽입, 삭제, 검색 연산은 $O(log_m,n)$에 수행할 수 있습니다. 이때 $m$은 트리의 평균 가지 수_{branching factor</sub>가 됩니다.</p>}

HashMap Implementation</h2>
각 언어의 해시맵 구현 방법을 알아보겠습니다. 마찬가지로 수업에서는 다루지 않았습니다.</em></p>

트리 DFS</h3>
우선 특정 노드에 대해서 다른 노드까지 가는 간선 비용의 총합</strong>을 구하는 방법을 생각해 봅시다. 이는 DFS+DP를 통해 $O(n)$으로 구현할 수 있습니다. </p>

도보시오</h2>

Codeforces - Rerooting Technique</a></li>
nicotina04 - Rerooting Tequnique on Tree</a></li>
Codeforces - Online Query Based Rerooting Technique</a></li> </ul>

zlfn.space

컴퓨터 아키텍처와 RISC-V

RV32I 명령어 세트</h2>

CSED311: Computer Architecture

B-Tree, B+Tree

CSED233: Data Structure

딕셔너리와 맵, 해싱

트리 리루팅 (전방향 트리 DP)

Docker를 이용한 리눅스 실습 환경 구축

순차탐색과 이분탐색

zlfn.space

컴퓨터 아키텍처와 RISC-V

RV32I 명령어 세트</h2>

CSED311: Computer Architecture

B-Tree, B+Tree

B-Tree of order m</h2> m진 탐색 트리는 아래와 같은 조건을 만족해야 합니다.</p>

Analysis</h3> B-Tree의 삽입, 삭제, 검색 연산은 $O(log_m,n)$에 수행할 수 있습니다. 이때 $m$은 트리의 평균 가지 수branching factor</sub>가 됩니다.</p>

CSED233: Data Structure

딕셔너리와 맵, 해싱

Dictionary ADT</h2> 딕셔너리는 추상 자료형Abstract Data Types</sub>의 일종으로, 특정 키에 대해 특정 원소가 매핑되는 짝의 집합으로 구성되어 있습니다.</p>

HashMap Implementation</h2> 각 언어의 해시맵 구현 방법을 알아보겠습니다. 마찬가지로 수업에서는 다루지 않았습니다.</em></p>

트리 리루팅 (전방향 트리 DP)

트리 DFS</h3> 우선 특정 노드에 대해서 다른 노드까지 가는 간선 비용의 총합</strong>을 구하는 방법을 생각해 봅시다. 이는 DFS+DP를 통해 $O(n)$으로 구현할 수 있습니다. </p>

Docker를 이용한 리눅스 실습 환경 구축

유저 만들기</h3> 이제 유저를 만들어서, SSH로 접속하게 되면 가짜 셸에 접속하게 합니다.</p>

순차탐색과 이분탐색

Analysis</h3>
B-Tree의 삽입, 삭제, 검색 연산은 $O(log_m,n)$에 수행할 수 있습니다. 이때 $m$은 트리의 평균 가지 수_{branching factor</sub>가 됩니다.</p>}

HashMap Implementation</h2>
각 언어의 해시맵 구현 방법을 알아보겠습니다. 마찬가지로 수업에서는 다루지 않았습니다.</em></p>

트리 DFS</h3>
우선 특정 노드에 대해서 다른 노드까지 가는 간선 비용의 총합</strong>을 구하는 방법을 생각해 봅시다. 이는 DFS+DP를 통해 $O(n)$으로 구현할 수 있습니다. </p>