디지털 논리회로 (Digital Logic Circuits)

배럴 시프터 (Barrel Shifter)

배럴 시프터(Barrel Shifter)는 한 클록 사이클에 임의의 비트 수만큼 시프트(Shift) 또는 로테이트(Rotate)를 수행하는 조합 논리회로입니다. CPU의 시프트/로테이트 명령(shl, shr, rol, ror)이 이 회로를 통해 실행됩니다. MUX 층을 로그 단계로 구성합니다: n비트 배럴 시프터는 log₂(n)개의 MUX 층을 사용합니다.

시프트 연산은 커널에서 매우 빈번하게 사용됩니다. 페이지 번호 계산(addr >> PAGE_SHIFT), 비트 마스크 생성(1UL << bit), 2의 거듭제곱 곱셈/나눗셈 등이 모두 배럴 시프터를 통해 하드웨어에서 단일 사이클로 실행됩니다. 산술 우측 시프트(SAR)는 부호 비트를 유지하여 부호 있는 정수의 2의 거듭제곱 나눗셈을 수행하고, 논리 우측 시프트(SHR)는 0으로 채워 부호 없는 정수에 사용됩니다.

ALU (산술 논리 장치)

ALU(Arithmetic Logic Unit, 산술 논리 장치)는 CPU의 핵심으로, 산술 연산(덧셈, 뺄셈)과 논리 연산(AND, OR, XOR, NOT)을 수행합니다. 연산 코드(Opcode)에 따라 가산기, 논리 유닛, 시프터 중 적절한 결과를 MUX로 선택하여 출력합니다.

ALU의 상태 플래그(Status Flags)는 조건 분기 명령의 기반입니다:

• Z (Zero) — 결과가 0이면 1. if (a == b)는 CMP(뺄셈) 후 Z 플래그 확인
• C (Carry) — 부호 없는 연산에서 올림/빌림 발생. 다중 정밀도 산술에 사용
• V (Overflow) — 부호 있는 연산에서 오버플로우 발생. 양수+양수=음수 등
• N (Negative) — 결과의 최상위 비트(MSB). 부호 있는 수에서 음수 표시

x86에서 이 플래그들은 EFLAGS/RFLAGS 레지스터에 저장되며, JZ(Zero일 때 점프), JC(Carry일 때 점프), JO(Overflow일 때 점프) 등의 조건 분기 명령이 이를 참조합니다. 컴파일러가 if (a > b)를 CMP + JG(부호 있는 비교) 또는 CMP + JA(부호 없는 비교)로 변환하는 것이 바로 이 메커니즘입니다.

/* 커널에서 ALU 연산이 직접 사용되는 예 */
/* atomic_add → ADD 명령 (lock prefix 포함) */
atomic_add(1, &counter);

/* 비트 테스트 → AND + 플래그 확인 (TEST 명령) */
if (test_bit(FLAG_BIT, &flags))
    do_something();

/* 시프트 → 배럴 시프터 */
unsigned long pfn = phys_addr >> PAGE_SHIFT;  /* SHR */
unsigned long addr = pfn << PAGE_SHIFT;      /* SHL */

/* 비교 → SUB + 플래그 (CMP 명령) */
if (a > b)  /* CMP a, b → 결과 버리고 플래그만 확인 */

리플 캐리 가산기와 올림 예측 가산기

리플 캐리 가산기(Ripple Carry Adder, RCA)는 n개의 전가산기를 직렬로 연결하여 n비트 덧셈을 수행합니다. 각 단계의 Cout이 다음 단계의 Cin으로 전파(Propagate)되므로, 비트 수가 증가하면 지연(Delay)이 선형으로 증가합니다.

올림 예측 가산기(Carry Lookahead Adder, CLA)는 각 비트에서 생성(Generate, G_i = A_i·B_i)과 전파(Propagate, P_i = A_i⊕B_i) 신호를 미리 계산하여, 올림을 병렬로 결정합니다. C₁ = G₀ + P₀·C₀, C₂ = G₁ + P₁·G₀ + P₁·P₀·C₀ 식으로 전개됩니다. 지연이 O(log n)으로 줄어들어 고속 가산기에 필수적입니다.

가산기 유형 비교:

실제 CPU의 64비트 가산기는 이러한 유형들을 계층적으로 결합합니다. 예를 들어 4비트 단위로 CLA를 적용하고, CLA 블록 간에는 올림 선택(Carry Select) 기법을 사용하는 방식입니다. 현대 프로세서의 가산기 지연은 수백 피코초 수준입니다.

뺄셈기와 2의 보수

뺄셈 A - B는 가산기를 재활용하여 A + (-B)로 수행합니다. 2의 보수(Two's Complement)에서 -B = ~B + 1이므로, B의 각 비트를 반전(NOT)하고 가산기의 C_in=1로 설정하면 뺄셈이 완료됩니다. 별도의 뺄셈기 회로가 필요 없습니다.

2의 보수(Two's Complement) 체계가 컴퓨터에서 보편적인 이유:

• 덧셈과 뺄셈에 동일한 가산기 회로를 사용할 수 있음
• 0의 표현이 유일함 (1의 보수에서는 +0과 -0이 존재)
• n비트에서 표현 범위: -2^n-1 ~ +2^n-1-1

커널에서 1의 보수가 사용되는 유일한 사례: IPv4 헤더 체크섬. ip_fast_csum() 함수는 1의 보수 합산을 수행하며, 올림(Carry)을 결과에 다시 더합니다(End-around Carry). 이외의 모든 정수 연산은 2의 보수를 사용합니다.

/* net/ipv4/ip_output.c — 1의 보수 체크섬 */
static inline __sum16 ip_fast_csum(const void *iph, unsigned int ihl)
{
    /* x86 어셈블리 최적화 버전 */
    /* ADC(Add with Carry) 명령 사용 → 하드웨어 캐리 플래그 활용 */
    /* 최종 올림(carry)을 결과에 다시 더함 = 1의 보수 합산 */
    /* 1의 보수의 장점: 바이트 순서(Endianness)에 무관한 체크섬 */
}

/* 2의 보수 오버플로우 감지 패턴 */
/* 양수 + 양수 = 음수 → 오버플로우 */
/* 음수 + 음수 = 양수 → 오버플로우 */
static inline bool add_would_overflow(s64 a, s64 b)
{
    return (b > 0 && a > S64_MAX - b) ||
           (b < 0 && a < S64_MIN - b);
    /* 하드웨어의 V(Overflow) 플래그와 동일한 검사 */
}

/* 커널에서의 2의 보수 활용 */
/* 부호 있는 정수의 부정: -x == ~x + 1 */
int neg = -value;           /* 컴파일러가 NEG 명령 생성 */

/* 오버플로우 감지 — ALU의 V(Overflow) 플래그 */
if (check_add_overflow(a, b, &result))
    return -EOVERFLOW;

/* include/linux/overflow.h */
#define check_add_overflow(a, b, d) __builtin_add_overflow(a, b, d)

순차 논리회로 (Sequential Logic)

순차 논리회로(Sequential Logic Circuit)는 조합 논리회로와 달리 기억 능력(Memory)을 가집니다. 출력이 현재 입력뿐만 아니라 이전 상태(Previous State)에도 의존합니다. 플립플롭(Flip-Flop)과 래치(Latch)가 순차 논리회로의 기본 기억 소자입니다.

래치는 레벨 트리거(Level-triggered)로 동작하여 클록 신호가 활성 상태인 동안 입력 변화를 반영하며, 플립플롭은 에지 트리거(Edge-triggered)로 동작하여 클록 신호의 상승 에지(Rising Edge) 또는 하강 에지(Falling Edge)에서만 입력을 포착합니다.

SR 래치의 내부 구조

SR 래치(SR Latch)는 순차 논리회로의 가장 기본적인 형태로, 두 개의 NOR 게이트(또는 NAND 게이트)를 교차 결합(Cross-coupled)하여 구성됩니다. 피드백 경로가 1비트의 상태를 유지합니다.

플립플롭 진리표

D 래치에서 D 플립플롭으로

D 래치(D Latch)는 클록이 High인 동안 입력을 투명하게 전달합니다(Transparent Latch). 이는 셋업/홀드 시간 위반의 원인이 될 수 있습니다. 마스터-슬레이브(Master-Slave) 구성으로 이 문제를 해결합니다:

1. 마스터 래치 — 클록이 Low일 때 입력을 포착
2. 슬레이브 래치 — 클록이 High일 때 마스터의 출력을 포착하여 최종 출력에 전달

결과적으로 클록의 상승 에지 순간에만 데이터가 전달되는 에지 트리거 동작이 됩니다. 현대 디지털 회로에서 D 플립플롭은 가장 보편적인 기억 소자이며, CPU 레지스터의 기본 빌딩 블록입니다.

D 플립플롭의 파생 구현:

• 비동기 리셋(Async Reset) — 클록과 무관하게 즉시 Q=0으로 리셋. 시스템 초기화에 사용
• 동기 리셋(Sync Reset) — 클록 에지에서만 리셋 적용. 글리치에 더 안전
• 인에이블 입력(Clock Enable) — EN=1일 때만 클록 에지에서 데이터 포착. 클록 게이팅의 논리적 등가
• 셋/리셋(Set/Reset) — 비동기로 Q=1(Set) 또는 Q=0(Reset) 강제. 파워온 초기화에 사용

/* Verilog HDL에서의 D 플립플롭 변형 */
/* 비동기 리셋 + 동기 인에이블 D-FF */
always @(posedge clk or posedge rst)
    if (rst)           /* 비동기 리셋 — 즉시 0 */
        q <= 1'b0;
    else if (en)       /* 인에이블일 때만 데이터 포착 */
        q <= d;
    /* else: q 유지 (래치 동작이 아님 — 이전 값 유지) */

4비트 이진 카운터 (Binary Counter)

T 플립플롭을 직렬로 연결하면 이진 카운터(Binary Counter)를 구성할 수 있습니다. 각 단계에서 주파수가 절반으로 분주(Division)됩니다.

링 카운터와 존슨 카운터

링 카운터(Ring Counter)는 시프트 레지스터의 마지막 출력을 첫 번째 입력으로 되돌린 것입니다. 한 번에 하나의 플립플롭만 1이 되는 원-핫(One-Hot) 순환을 합니다. n비트 링 카운터는 n개의 상태를 가집니다. 시퀀스 생성기, 라운드 로빈 스케줄러(Round-Robin Scheduler)의 하드웨어 구현에 사용됩니다.

존슨 카운터(Johnson Counter)는 시프트 레지스터의 마지막 출력을 반전(NOT)하여 첫 번째 입력으로 되돌린 것입니다. n비트 존슨 카운터는 2n개의 상태를 가지며, 인접 상태 간 1비트만 변하는 특성(그레이 코드와 유사)이 있어 글리치 없는 디코딩이 가능합니다.

시프트 레지스터 (Shift Register)

시프트 레지스터(Shift Register)는 D 플립플롭을 직렬로 연결하여 데이터를 한 비트씩 이동시키는 회로입니다. 직렬-병렬 변환(Serial-to-Parallel Conversion)과 병렬-직렬 변환(Parallel-to-Serial Conversion)에 사용되며, SPI, I2C 등의 직렬 통신 인터페이스의 기반입니다.

4가지 동작 모드가 있습니다:

• SISO(Serial In, Serial Out) — 직렬 입력, 직렬 출력. 지연선(Delay Line)으로 사용
• SIPO(Serial In, Parallel Out) — 직렬 입력, 병렬 출력. 직렬→병렬 변환기 (SPI 수신)
• PISO(Parallel In, Serial Out) — 병렬 입력, 직렬 출력. 병렬→직렬 변환기 (SPI 송신)
• PIPO(Parallel In, Parallel Out) — 병렬 입력, 병렬 출력. 버퍼 레지스터

/* drivers/spi/spi.c — SPI 프레임워크 */
/* SPI 통신은 시프트 레지스터의 직접적인 응용 */
/* 마스터의 MOSI(시프트 아웃) → 슬레이브의 시프트 레지스터 입력 */
/* 슬레이브의 MISO(시프트 아웃) → 마스터의 시프트 레지스터 입력 */
struct spi_transfer {
    const void     *tx_buf;    /* PISO: 병렬→직렬로 송신 */
    void           *rx_buf;    /* SIPO: 직렬→병렬로 수신 */
    unsigned       len;        /* 전송 바이트 수 */
    u32            speed_hz;   /* 시프트 클록 주파수 */
    u8             bits_per_word; /* 시프트 레지스터 폭 */
};

유한 상태 머신 (FSM)

유한 상태 머신(Finite State Machine, FSM)은 유한한 수의 상태(State)와 상태 전이(Transition)를 가지는 모델입니다. 디지털 회로에서는 플립플롭(상태 저장)과 조합 논리(다음 상태/출력 결정)의 조합으로 구현됩니다.

두 가지 유형이 있습니다:

• 무어 머신(Moore Machine) — 출력이 현재 상태에만 의존 (출력 = f(상태))
• 밀리 머신(Mealy Machine) — 출력이 현재 상태와 입력에 모두 의존 (출력 = f(상태, 입력))

/* 커널 장치 드라이버에서의 FSM 구현 예시 */
/* USB 장치 상태 머신 (drivers/usb/) */
enum usb_device_state {
    USB_STATE_NOTATTACHED = 0,    /* 미연결 */
    USB_STATE_ATTACHED,            /* 물리적 연결됨 */
    USB_STATE_POWERED,             /* 전원 공급됨 */
    USB_STATE_RECONNECTING,
    USB_STATE_UNAUTHENTICATED,
    USB_STATE_DEFAULT,             /* 리셋 후 기본 상태 */
    USB_STATE_ADDRESS,             /* 주소 할당됨 */
    USB_STATE_CONFIGURED,          /* 설정 완료, 사용 가능 */
    USB_STATE_SUSPENDED,           /* 절전 모드 */
};

/* 상태 전이 함수 — 하드웨어 FSM의 "다음 상태 논리"에 해당 */
void usb_set_device_state(struct usb_device *udev,
                          enum usb_device_state new_state)
{
    /* 유효한 전이만 허용 (FSM 전이 테이블 검증) */
    unsigned long flags;
    spin_lock_irqsave(&device_state_lock, flags);
    /* ... 상태 전이 로직 ... */
    udev->state = new_state;
    spin_unlock_irqrestore(&device_state_lock, flags);
}

무어 머신과 밀리 머신의 실용적 차이: 무어 머신은 출력이 클록에 동기화되어 글리치가 없지만 응답이 1클록 느립니다. 밀리 머신은 입력 변화에 즉시 반응하지만 조합 논리 경로의 글리치가 출력에 나타날 수 있습니다. 대부분의 실제 설계는 두 유형을 혼합하여 사용합니다.

FSM 설계의 상태 인코딩(State Encoding) 방법:

FPGA에서는 FF이 풍부하고 조합 논리(LUT)가 제한적이므로 원-핫 인코딩이 기본입니다. ASIC에서는 면적 최적화를 위해 이진 인코딩을 사용합니다. 커널의 소프트웨어 FSM은 enum으로 상태를 정의하므로 이진 인코딩에 해당하며, switch-case 문이 디코딩 로직에 대응합니다.

/* 커널의 FSM 구현 패턴 비교 */

/* 패턴 1: switch-case (가장 일반적) */
switch (dev->state) {
case STATE_IDLE:
    if (event == EVENT_START)
        dev->state = STATE_RUNNING;
    break;
case STATE_RUNNING:
    if (event == EVENT_DONE)
        dev->state = STATE_IDLE;
    break;
}

/* 패턴 2: 함수 포인터 테이블 (복잡한 FSM) */
typedef void (*state_handler_t)(struct device *dev, int event);
static const state_handler_t handlers[NUM_STATES] = {
    [STATE_IDLE]    = handle_idle,
    [STATE_RUNNING] = handle_running,
    [STATE_ERROR]   = handle_error,
};
handlers[dev->state](dev, event);
/* → 배열 인덱스 접근 = 하드웨어 MUX 선택과 동일 원리 */

LFSR (선형 궤환 시프트 레지스터)

LFSR(Linear Feedback Shift Register, 선형 궤환 시프트 레지스터)은 시프트 레지스터의 특정 비트를 XOR하여 입력으로 되돌리는 회로입니다. 최대 길이(Maximum Length) LFSR은 2ⁿ-1개의 서로 다른 상태를 순환하며, 의사 난수(Pseudo-random) 수열을 생성합니다.

커널에서의 LFSR 응용:

• CRC 계산 — lib/crc32.c의 CRC32 알고리즘은 본질적으로 LFSR의 소프트웨어 구현입니다. 네트워크 패킷, 파일 시스템 무결성 검증에 사용됩니다.
• 난수 생성 — drivers/char/random.c에서 엔트로피 풀의 혼합(Mixing)에 사용됩니다.
• 해시 함수 — 해시 테이블의 분산(Distribution)을 개선하기 위한 비트 혼합에 활용됩니다.

/* lib/crc32.c — CRC32는 LFSR의 소프트웨어 구현 */
u32 crc32_le(u32 crc, unsigned char const *p, size_t len)
{
    while (len--) {
        crc ^= *p++;
        for (int i = 0; i < 8; i++)
            crc = (crc >> 1) ^ ((crc & 1) ? 0xEDB88320 : 0);
            /* 0xEDB88320 = CRC32의 생성 다항식(역순) */
    }
    return crc;
}

메모리 소자 (Memory Elements)

메모리 소자(Memory Element)는 데이터를 저장하고 유지하는 회로입니다. 플립플롭에서 발전한 레지스터(Register)와 대용량 저장을 위한 SRAM, DRAM, 그리고 비휘발성(Non-volatile) 메모리까지 다양한 형태가 존재합니다.

6T SRAM 셀

SRAM(Static Random Access Memory)은 전원이 공급되는 한 데이터를 유지하는 휘발성(Volatile) 메모리입니다. 6T(6-Transistor) 구조가 가장 보편적이며, 교차 결합 인버터(Cross-coupled Inverter) 쌍이 1비트를 저장합니다.

1T1C DRAM 셀

DRAM(Dynamic Random Access Memory)은 커패시터(Capacitor)에 전하를 저장하여 1비트를 기억합니다. SRAM보다 구조가 단순하여 높은 집적도(Density)를 달성할 수 있지만, 전하 누설(Leakage)로 인해 주기적인 리프레시(Refresh)가 필요합니다.

SRAM vs DRAM 비교

캐시 메모리 구성

캐시 메모리(Cache Memory)는 CPU와 메인 메모리 사이의 속도 차이를 해결하기 위한 소용량 고속 SRAM입니다. 주소를 태그(Tag), 인덱스(Index), 오프셋(Offset)으로 분해하여 캐시 라인(Cache Line)을 찾습니다.

캐시 적중(Cache Hit)과 캐시 미스(Cache Miss)의 처리:

/* 캐시 라인 크기와 커널 자료 구조 정렬 */
/* 대부분의 현대 CPU: 캐시 라인 = 64바이트 */
#define L1_CACHE_BYTES     64
#define ____cacheline_aligned __attribute__((__aligned__(L1_CACHE_BYTES)))

/* false sharing 방지 — 캐시 라인 경계에 정렬 */
struct per_cpu_data {
    unsigned long counter;
    unsigned long flags;
} ____cacheline_aligned;
/* 각 CPU의 데이터가 별도의 캐시 라인에 위치 */
/* → 한 CPU의 쓰기가 다른 CPU의 캐시를 무효화하지 않음 */

/* prefetch — 캐시 강제 미스를 사전에 해결 */
prefetch(&next_node->data);  /* 다음 접근할 데이터를 미리 캐시에 로드 */
/* → 하드웨어 프리페치 유닛에 힌트 제공 */

캐시의 하드웨어 구현은 이 페이지의 모든 조합/순차 논리 개념을 총동원합니다: 태그 비교(비교기), 세트 선택(디코더), 웨이 선택(MUX), 데이터 저장(SRAM = 크로스 커플드 인버터), 교체 정책(FSM + 카운터), 코히런스 프로토콜(분산 FSM). 상세한 캐시 아키텍처는 CPU 캐시 페이지를 참조하세요.

DRAM 타이밍과 리프레시

DRAM 접근은 행(Row) 활성화와 열(Column) 선택의 2단계로 이루어집니다. 주요 타이밍 파라미터:

DDR(Double Data Rate)은 클록의 상승 에지와 하강 에지 양쪽에서 데이터를 전송합니다. DDR4-3200은 1600MHz 클록에서 3200 MT/s(Mega Transfers per second)를 달성합니다. DDR5는 버스트 길이(Burst Length)를 16으로 늘리고, 채널 분할(Sub-channel)을 도입하여 대역폭을 더 향상시켰습니다.

리프레시는 모든 DRAM 행을 주기적으로 읽고 다시 쓰는 과정입니다. 64ms 이내에 모든 행을 리프레시해야 합니다. 리프레시 중에는 해당 뱅크(Bank)에 접근할 수 없으므로 성능에 영향을 줍니다. 커널의 메모리 컨트롤러 드라이버는 이 타이밍 파라미터를 SPD(Serial Presence Detect) EEPROM에서 읽어 자동으로 설정합니다.

DRAM 접근 시퀀스 (타이밍 관점):

1. 행 활성화(Row Activate, ACT) — 행 주소를 보내고 행을 센스 앰프에 로드. tRCD 대기
2. 열 접근(Column Read/Write) — 열 주소를 보내고 읽기/쓰기 수행. CL 대기(읽기 시)
3. 행 프리차지(Row Precharge, PRE) — 행을 닫고 센스 앰프 초기화. tRP 대기
4. 다음 행 접근 — 같은 뱅크의 다른 행에 접근하려면 프리차지 필수 (행 충돌)

행 적중(Row Hit)은 이미 활성화된 행에 재접근하는 것으로 매우 빠릅니다. 행 충돌(Row Conflict)은 프리차지 + 활성화 지연이 추가됩니다. 커널의 메모리 할당자가 연속 물리 페이지를 할당하면 행 적중률이 높아집니다.

/* SPD EEPROM 읽기 — DRAM 모듈 타이밍 정보 */
/* dmidecode로 확인 가능 */
/* $ dmidecode -t memory */
/* Memory Device */
/*   Speed: 3200 MT/s */
/*   Type: DDR4 */
/*   Data Width: 64 bits */

/* DRAM 뱅크 인터리빙 — 연속 주소를 다른 뱅크에 분산 배치 */
/* → 뱅크 수준 병렬성(Bank-Level Parallelism) 확보 */
/* 커널의 buddy allocator가 연속 페이지를 할당하면 */
/* 자연스럽게 여러 뱅크에 걸치는 접근이 됨 */

ECC 메모리

ECC(Error-Correcting Code) 메모리는 단일 비트 오류를 자동 정정하고 이중 비트 오류를 감지합니다. SEC-DED(Single Error Correction, Double Error Detection) 방식이 가장 보편적이며, 해밍 코드(Hamming Code)를 기반으로 합니다.

64비트 데이터에 8비트 ECC 체크비트를 추가하여 (72비트 = 64+8) 단일 비트 오류를 정정합니다. 서버와 임베디드 시스템에서 필수적이며, 커널의 EDAC(Error Detection And Correction) 서브시스템이 ECC 오류를 모니터링합니다.

해밍 코드의 원리: 체크 비트를 2의 거듭제곱 위치(1, 2, 4, 8, ...)에 배치합니다. 각 체크 비트는 특정 비트 위치 집합의 패리티(Parity)를 계산합니다. 오류 발생 시 체크 비트들의 조합(신드롬, Syndrome)이 오류 비트의 위치를 직접 가리킵니다. 이 신드롬은 본질적으로 오류 위치의 이진 인코딩이며, XOR 게이트 트리로 하드웨어에서 매우 효율적으로 구현됩니다.

/* drivers/edac/ — ECC 오류 보고 */
/* 정정 가능한 오류 (CE: Correctable Error) */
edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci,
    1,  /* error count */
    page, offset, syndrome,
    row, channel, -1,
    msg, "");

/* 정정 불가능한 오류 (UE: Uncorrectable Error) → 커널 패닉 가능 */
edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, ...);

플래시 메모리 내부 구조

플래시 메모리는 플로팅 게이트(Floating Gate) 트랜지스터를 사용합니다. 플로팅 게이트에 전자를 주입(프로그램)하면 문턱 전압(Threshold Voltage)이 변하여 비트를 저장합니다. 터널링(Tunneling) 효과로 전자를 제거하여 지웁니다(Erase).

플로팅 게이트 동작 원리: 일반 MOSFET의 게이트와 채널 사이에 절연체(산화막)로 둘러싸인 추가 게이트(플로팅 게이트)를 삽입한 구조입니다. 프로그램 시 제어 게이트에 고전압(~20V)을 인가하면 전자가 Fowler-Nordheim 터널링 또는 핫 캐리어 주입(Hot-Carrier Injection)으로 플로팅 게이트에 갇힙니다. 전자가 갇히면 트랜지스터의 문턱 전압이 상승하여, 읽기 시 인가하는 기준 전압으로는 채널이 열리지 않습니다 (논리 0). 전자가 없으면 채널이 열려 전류가 흐릅니다 (논리 1). 지우기 시에는 기판에 고전압을 인가하여 전자를 다시 빼냅니다. 이 과정에서 산화막이 점진적으로 열화되어 수명이 제한됩니다.

NOR 플래시와 NAND 플래시의 셀 배열 구조가 다릅니다. NOR 플래시는 각 셀이 비트 라인에 병렬로 연결되어 바이트 단위 랜덤 접근이 가능하므로 XIP(eXecute In Place) 부팅에 사용됩니다. NAND 플래시는 셀이 직렬로 연결(NAND 스트링)되어 순차 접근에 최적화되었지만, 셀 면적이 작아 높은 집적도를 달성합니다.

NAND 플래시의 핵심 제약:

• 쓰기 전 지우기 — 0→1 전환은 블록 단위 지우기(Erase)가 필요
• 블록 크기 — 지우기 단위는 수십 KB~수 MB
• 수명 제한 — 프로그램/지우기 사이클 수 제한 (SLC: ~100K, TLC: ~3K)
• 웨어 레벨링(Wear Leveling) — FTL(Flash Translation Layer)이 블록 사용을 균등화

커널의 MTD(Memory Technology Device) 서브시스템과 UBI(Unsorted Block Images) 계층이 이러한 하드웨어 특성을 추상화합니다. 자세한 내용은 MTD와 플래시 파일 시스템 페이지를 참조하세요.

/* drivers/mtd/nand/ — NAND 플래시 드라이버 */
/* 하드웨어의 지우기-쓰기 제약을 소프트웨어가 관리 */
struct nand_chip {
    int (*erase)(struct nand_device *nand,
                const struct nand_pos *pos);
    int (*read_page)(struct nand_device *nand,
                    const struct nand_page_io_req *req);
    int (*write_page)(struct nand_device *nand,
                     const struct nand_page_io_req *req);
    unsigned int erasesize;  /* 블록 크기 (지우기 단위) */
    unsigned int writesize;  /* 페이지 크기 (쓰기 단위) */
    unsigned int oobsize;    /* OOB 영역 (ECC 저장) */
};

/* SLC/MLC/TLC/QLC — 셀당 비트 수 */
/* SLC: 1비트/셀, 2개 전압 레벨 → 가장 빠르고 내구성 높음 */
/* TLC: 3비트/셀, 8개 전압 레벨 → 높은 밀도, 낮은 내구성 */
/* QLC: 4비트/셀, 16개 전압 레벨 → 최고 밀도, 최저 내구성 */

SLC(Single-Level Cell)에서 QLC(Quad-Level Cell)로 갈수록 하나의 셀에 더 많은 비트를 저장하지만, 전압 레벨 간 마진이 줄어들어 오류율이 증가합니다. 이는 디지털 논리의 노이즈 마진(Noise Margin) 개념과 직접 관련됩니다. 커널의 ECC 소프트웨어(BCH, LDPC)가 이 오류를 정정합니다.

FTL(Flash Translation Layer)은 NAND 플래시의 "쓰기 전 지우기" 제약을 숨기는 핵심 소프트웨어/펌웨어 계층입니다. 논리 블록 주소(LBA)를 물리 블록 주소(PBA)로 매핑하는 테이블을 유지하며, 이는 본질적으로 디코더(주소 변환)와 테이블 룩업(LUT)의 소프트웨어 구현입니다. 커널의 dm-zoned, f2fs 등이 이러한 특성을 인식한 파일 시스템입니다.

ROM 유형 비교

버스와 인터커넥트 (Bus & Interconnect)

버스(Bus)는 시스템 내 여러 구성 요소 간에 데이터를 전송하는 공유 통신 경로입니다. 주소 버스(Address Bus), 데이터 버스(Data Bus), 제어 버스(Control Bus)의 세 가지로 분류됩니다.

버스 유형과 역할

직렬 vs 병렬 버스

역사적으로 병렬 버스(Parallel Bus)가 먼저 사용되었지만, 현대 고속 인터커넥트는 대부분 직렬 버스(Serial Bus)입니다. 이유는 신호 간 타이밍 스큐(Skew) 문제입니다. 병렬 버스에서 수십 개의 신호선이 정확히 동시에 도착해야 하는데, 고주파에서는 이것이 매우 어렵습니다.

병렬 버스의 한계를 이해하려면 전파 지연의 물리적 특성을 고려해야 합니다. 신호는 PCB(Printed Circuit Board) 위를 빛의 속도의 약 50~60%로 전파됩니다 (~15cm/ns). 32비트 병렬 버스에서 32개의 트레이스(Trace) 길이가 정확히 같지 않으면 비트 간 도착 시간 차이(Skew)가 발생합니다. 1GHz에서 1ns 주기의 10%인 100ps 스큐만으로도 데이터 오류가 발생할 수 있습니다. 직렬 버스는 단일 차동 쌍(Differential Pair)만 사용하므로 이 문제가 원천적으로 해결됩니다.

차동 신호(Differential Signaling)는 현대 직렬 버스의 핵심입니다. 두 개의 와이어에 반대 극성의 신호를 보내고, 수신 측에서 차이(V+ - V-)를 감지합니다. 공통 모드 잡음(Common-Mode Noise)이 양쪽 와이어에 동일하게 영향을 주므로, 차이를 취하면 잡음이 상쇄됩니다. LVDS(Low-Voltage Differential Signaling)가 대표적이며, PCIe, USB, SATA 모두 차동 신호를 사용합니다.

직렬 버스는 SerDes(Serializer/Deserializer)를 사용하여 병렬 데이터를 직렬화하고, 수신 측에서 클록 복원(Clock Recovery)을 통해 데이터를 추출합니다. 레인 수를 늘려 대역폭을 확보합니다 (예: PCIe x16 = 16레인).

SerDes의 디지털 논리회로 관점:

• 직렬화기(Serializer) — PISO(Parallel-In Serial-Out) 시프트 레지스터. 병렬 데이터를 한 비트씩 내보냄
• 역직렬화기(Deserializer) — SIPO(Serial-In Parallel-Out) 시프트 레지스터. 직렬 비트를 병렬 워드로 복원
• PLL (Clock Recovery) — 수신 데이터 스트림에서 클록을 추출. CDR(Clock and Data Recovery) 회로
• 8b/10b 또는 64b/66b 인코딩 — DC 밸런스 유지와 클록 복원을 위한 라인 코딩. LUT으로 구현

/* PCIe 링크 훈련(Link Training) — 하드웨어 FSM */
/* 커널의 PCIe 드라이버가 이 과정을 모니터링 */
/* Detect → Polling → Configuration → L0 (정상 동작) */
/* 각 상태에서 SerDes의 이퀄라이제이션(Equalization) 조정 */

/* lspci -vv에서 확인 가능한 링크 상태 */
/* LnkSta: Speed 16GT/s, Width x16 */
/* → 16 레인 × 16GT/s × 128/130 (인코딩 효율) ≈ 63 GB/s */

/* 커널의 PCIe 속도 제어 */
/* /sys/bus/pci/devices/.../max_link_speed */
/* /sys/bus/pci/devices/.../current_link_speed */

AXI/AHB 버스 프로토콜

ARM AMBA(Advanced Microcontroller Bus Architecture) 패밀리는 SoC(System on Chip) 내부 인터커넥트의 사실상 표준입니다. AXI(Advanced eXtensible Interface)는 가장 고성능 사양으로, 5개의 독립 채널을 사용합니다.

네트워크 온 칩 (NoC)

최신 SoC는 수십 개의 IP 블록을 포함하며, 공유 버스로는 대역폭과 확장성이 부족합니다. 네트워크 온 칩(NoC, Network on Chip)은 라우터와 링크로 구성된 패킷 스위칭 네트워크를 칩 내부에 구현합니다. 메시(Mesh), 링(Ring), 트리(Tree) 등의 토폴로지가 사용됩니다.

Intel의 링 버스(Ring Bus)와 메시 인터커넥트(Mesh Interconnect), ARM의 CMN(Coherent Mesh Network)이 대표적입니다. 커널의 NUMA 토폴로지 인식은 이러한 NoC 구조와 직접 관련됩니다.

각 라우터 내부에는 FIFO 버퍼(시프트 레지스터 기반), 교차점 스위치(MUX 기반), 라우팅 로직(조합 논리)이 포함됩니다. NoC의 라우팅 알고리즘(XY 라우팅, 적응형 라우팅)은 FSM으로 구현됩니다.

캐시 일관성(Cache Coherence) 프로토콜도 NoC 위에서 동작하는 분산 FSM입니다. MOESI/MESIF 프로토콜의 각 상태 전이가 NoC 메시지로 전달됩니다. 커널의 smp_mb()와 같은 메모리 배리어는 이 프로토콜에 영향을 주어, 모든 코어가 일관된 메모리 뷰를 갖도록 보장합니다.

/* NUMA 토폴로지 인식 — NoC 구조 반영 */
/* /proc/sys/kernel/numa_balancing */
/* 커널은 메모리 접근 지연(NoC 홉 수)에 따라 */
/* 프로세스를 가까운 NUMA 노드로 마이그레이션 */

/* 노드 간 거리 확인 */
int distance = node_distance(node_a, node_b);
/* 거리 = NoC에서 두 노드 간 홉(hop) 수에 비례 */

/* sched_domain 계층 — NoC 토폴로지 반영 */
/* SMT → MC (Multi-Core) → DIE → NUMA */
/* 각 레벨이 물리적 인터커넥트 계층에 대응 */

버스 중재 (Bus Arbitration)

여러 버스 마스터(Bus Master)가 동시에 버스를 사용하려 할 때 충돌을 방지하기 위한 메커니즘입니다. 중앙 집중식(Centralized) 방식과 분산(Distributed) 방식이 있습니다. DMA 컨트롤러가 버스 마스터 권한을 획득하여 CPU 개입 없이 메모리에 직접 접근하는 것이 대표적인 예입니다.

클록과 타이밍 (Clock & Timing)

클록 신호(Clock Signal)는 동기식(Synchronous) 디지털 회로에서 모든 동작의 기준이 되는 주기적 구형파(Square Wave)입니다. 플립플롭의 에지 트리거, 데이터 전송 타이밍, 파이프라인(Pipeline) 스테이지 전환이 모두 클록에 동기화됩니다.

셋업 시간과 홀드 시간

플립플롭이 데이터를 정확히 포착하려면 클록 에지 전후로 데이터가 안정 상태를 유지해야 합니다. 이 제약 조건을 셋업 시간(Setup Time, t_su)과 홀드 시간(Hold Time, t_h)이라 합니다.

메타안정성 (Metastability)

셋업 시간 또는 홀드 시간이 위반되면 플립플롭의 출력이 0도 1도 아닌 불확정 상태에 머무를 수 있습니다. 이것이 메타안정 상태입니다. 출력이 결정되기까지 비정상적으로 긴 시간이 소요되며, 이 동안 다운스트림 로직에 오류가 전파될 수 있습니다.

클록 트리 분배

클록 트리(Clock Tree)는 클록 소스에서 칩 내 모든 플립플롭까지 클록 신호를 균등하게 분배하는 네트워크입니다. H-트리(H-tree) 구조가 대표적이며, 클록 버퍼(Buffer)를 삽입하여 신호 감쇠를 보상합니다.

클록 스큐(Clock Skew)는 같은 클록이 서로 다른 플립플롭에 도달하는 시간 차이입니다. 지터(Jitter)는 클록 에지의 시간적 불확실성입니다. 둘 다 타이밍 마진(Timing Margin)을 줄여 최대 클록 주파수를 제한합니다. 클록 트리 합성(CTS, Clock Tree Synthesis)은 EDA 도구의 핵심 단계입니다.

현대 프로세서의 클록 분배 구조:

• 글로벌 클록 — PLL에서 생성된 기준 클록이 H-트리 또는 스파인(Spine) 구조로 분배
• 클록 게이팅 — AND 게이트로 미사용 블록의 클록을 차단 (동적 전력 절감의 핵심)
• 클록 분주기(Divider) — 카운터 회로로 클록 주파수를 낮춤 (예: 코어 클록 / 2 = 언코어 클록)
• 클록 멀티플렉서 — 여러 클록 소스 중 하나를 선택 (PLL 출력, 바이패스 클록 등)

/* drivers/clk/ — 커널 클록 프레임워크 */
/* 하드웨어 클록 트리를 소프트웨어로 모델링 */
struct clk_hw {
    struct clk_core         *core;
    struct clk              *clk;
    const struct clk_init_data *init;
};

/* 클록 게이팅: clk_gate — AND 게이트에 대응 */
clk_prepare_enable(clk);   /* 게이트 열기 (클록 공급 시작) */
clk_disable_unprepare(clk); /* 게이트 닫기 (클록 차단) */

/* 클록 분주기: clk_divider — 카운터에 대응 */
clk_set_rate(clk, rate);   /* 분주 비율 변경 */

/* 클록 MUX: clk_mux — 멀티플렉서에 대응 */
clk_set_parent(clk, parent); /* 클록 소스 선택 */

2단 플립플롭 동기화기

서로 다른 클록 도메인 간에 신호를 전달할 때 메타안정성 문제를 해결하는 표준 방법입니다. 비동기 입력을 목적 클록 도메인의 D 플립플롭 2개에 직렬로 통과시킵니다.

비동기 FIFO

다수의 비트를 클록 도메인 간에 안전하게 전달하려면 비동기 FIFO(Asynchronous FIFO)를 사용합니다. 핵심은 그레이 코드(Gray Code) 포인터입니다. 그레이 코드에서는 인접한 값 사이에 1비트만 변하므로, 메타안정 상태가 발생하더라도 최대 1비트 오차만 발생합니다.

비동기 FIFO의 핵심 설계 요소:

• 듀얼 포트 SRAM — 쓰기 포트(CLK_W)와 읽기 포트(CLK_R)가 독립 클록. SRAM의 물리적 구조가 이를 지원
• 그레이 코드 포인터 — 이진 카운터를 그레이 코드로 변환하여 CDC 경계를 넘김. 변환 공식: Gray = Binary XOR (Binary >> 1)
• FULL 조건 — 쓰기 포인터가 읽기 포인터를 한 바퀴 앞서면 FULL. MSB가 다르고 나머지 비트가 같음
• EMPTY 조건 — 읽기 포인터가 쓰기 포인터와 같으면 EMPTY

/* 그레이 코드 변환 — 커널에서도 사용 가능 */
static inline unsigned int binary_to_gray(unsigned int binary)
{
    return binary ^ (binary >> 1);
    /* XOR 게이트 하나로 구현 — 매우 간단한 조합 논리 */
}

static inline unsigned int gray_to_binary(unsigned int gray)
{
    unsigned int binary = gray;
    while (gray >>= 1)
        binary ^= gray;
    return binary;
}

/* 그레이 코드 순서: 0→1→3→2→6→7→5→4 (3비트) */
/* 인접 값 간 항상 1비트만 변함 → 메타안정 시 최대 1비트 오차 */

비동기 FIFO는 네트워크 인터페이스(PHY 클록 ↔ 시스템 클록), 오디오 인터페이스(I2S 클록 ↔ 버스 클록), 디스플레이 컨트롤러(픽셀 클록 ↔ 메모리 클록) 등 서로 다른 클록 도메인 간의 데이터 전달에 필수적입니다. 커널의 kfifo 구현은 소프트웨어 FIFO이지만, 하드웨어 비동기 FIFO와 동일한 생산자-소비자(Producer-Consumer) 패턴을 따릅니다.

PLL과 클록 체계

위상 고정 루프(PLL, Phase-Locked Loop)는 기준 클록에서 더 높거나 낮은 주파수의 클록을 생성합니다. 현대 프로세서는 100MHz 기준 클록에서 PLL을 통해 수 GHz의 코어 클록을 합성합니다.

PLL의 기본 구성 요소:

• 위상 검출기(Phase Detector) — XOR 게이트 또는 위상-주파수 검출기(PFD). 기준 클록과 피드백 클록의 위상 차이를 검출
• 루프 필터(Loop Filter) — 저역 통과 필터(LPF). 위상 오차 신호를 평활화
• 전압 제어 발진기(VCO) — 입력 전압에 비례하는 주파수 출력. 링 발진기(Ring Oscillator) — 홀수 개의 인버터를 직렬 연결
• 분주기(Divider) — VCO 출력을 N으로 나누어 피드백. 출력 주파수 = 기준 주파수 × N

PLL의 잠금(Lock) 과정은 피드백 제어 시스템입니다. 주파수 변경 시 PLL이 새 주파수에 안정화되기까지 수 마이크로초~수백 마이크로초가 소요됩니다. 이것이 커널의 CPU 주파수 변경에 지연이 있는 물리적 이유입니다.

커널과의 관계 (Relation to Kernel)

디지털 논리회로의 각 구성 요소는 리눅스 커널의 다양한 서브시스템과 직접적으로 연결됩니다. 하드웨어의 물리적 동작을 이해하면 커널 코드의 설계 의도를 더 깊이 파악할 수 있습니다.

레지스터 파일과 컨텍스트 스위칭

CPU 레지스터 파일(Register File)은 D 플립플롭의 2차원 배열과 MUX/DEMUX의 조합입니다. 읽기 포트(Read Port)는 MUX를 통해 원하는 레지스터를 선택하고, 쓰기 포트(Write Port)는 디코더를 통해 대상 레지스터를 지정합니다.

/* arch/x86/include/asm/switch_to.h — 컨텍스트 스위칭 */
#define switch_to(prev, next, last) \
do { \
    prepare_switch_to(next); \
    ((last) = __switch_to_asm((prev), (next))); \
} while (0)

/* arch/x86/entry/entry_64.S — 실제 레지스터 저장/복원 */
/* 레지스터 파일의 내용을 스택에 push/pop */
/* pushq %rbp; pushq %rbx; pushq %r12~%r15 */
/* movq %rsp, TASK_threadsp(%rdi) — 스택 포인터 저장 */
/* movq TASK_threadsp(%rsi), %rsp — 새 스택 복원 */
/* popq %r15~%r12; popq %rbx; popq %rbp */

메모리 컨트롤러와 페이지 할당

DRAM의 행, 열, 뱅크 구조는 커널의 페이지 할당자와 NUMA 정책에 영향을 줍니다. 메모리 컨트롤러의 디코더가 물리 주소를 행/뱅크/열로 분해하는 방식은 메모리 접근 패턴의 성능에 직접적인 영향을 미칩니다.

커널의 struct zone과 struct pglist_data는 물리 메모리의 DRAM 토폴로지를 반영하며, 버디 시스템은 연속된 물리 페이지 할당을 통해 DRAM 뱅크 인터리빙의 이점을 활용합니다.

인터럽트 컨트롤러

인터럽트 컨트롤러는 우선순위 인코더(조합 논리회로)와 인터럽트 마스크 레지스터(플립플롭 배열)의 조합입니다. x86의 APIC과 ARM의 GIC는 모두 이러한 디지털 논리회로로 구현됩니다.

커널이 local_irq_disable()를 호출하면 인터럽트 플래그(IF) 플립플롭이 클리어되어 인터럽트 요청이 CPU에 도달하지 못합니다.

/* 인터럽트 컨트롤러 제어 — 하드웨어 레지스터 직접 조작 */
/* x86 LAPIC (Local APIC) */
static void lapic_mask_irq(struct irq_data *data)
{
    unsigned long v;
    v = apic_read(APIC_LVT_BASE + data->hwirq);
    v |= APIC_LVT_MASKED;  /* 비트 16 설정 → 마스크 레지스터의 해당 FF set */
    apic_write(APIC_LVT_BASE + data->hwirq, v);
}

/* ARM GIC (Generic Interrupt Controller) */
/* GICD_ISENABLER: 인터럽트 활성화 (Set-Enable Register) */
/* GICD_ICENABLER: 인터럽트 비활성화 (Clear-Enable Register) */
/* 각 비트가 하나의 인터럽트 라인에 대응하는 플립플롭 */
writel_relaxed(mask, base + GICD_ISENABLER + (irq / 32) * 4);

/* 인터럽트 우선순위 설정 → 우선순위 인코더의 비교값 변경 */
writel_relaxed(priority, base + GICD_IPRIORITYR + irq);

DMA 엔진

DMA(Direct Memory Access) 컨트롤러는 카운터, 상태 머신, 버스 중재 로직의 조합입니다. 전송 바이트 수를 세는 카운터가 0에 도달하면 완료 인터럽트를 발생시킵니다. 이 모든 동작이 디지털 논리회로로 구현됩니다.

DMA 컨트롤러의 내부 구조를 논리회로 관점에서 분석하면:

• 소스/목적지 주소 레지스터 — D 플립플롭 배열 + 증가기(Incrementer). 매 전송마다 주소가 자동 증가
• 전송 카운트 레지스터 — 감소 카운터. 0 도달 시 완료 신호 생성 (Zero 플래그)
• 상태 머신(FSM) — IDLE → REQUEST → TRANSFER → DONE 상태 전이
• 버스 중재 로직 — CPU에 버스 요청(BUSREQ) 신호를 보내고, 승인(BUSACK)을 기다림

/* DMA 채널 설정 — 하드웨어 레지스터에 직접 대응 */
struct dma_slave_config {
    enum dma_transfer_direction direction;
    dma_addr_t  src_addr;      /* 소스 주소 레지스터 */
    dma_addr_t  dst_addr;      /* 목적지 주소 레지스터 */
    u32         src_addr_width; /* 데이터 버스 폭 */
    u32         dst_addr_width;
    u32         src_maxburst;  /* 버스트 전송 길이 */
    u32         dst_maxburst;
};

/* DMA 전송 시작 → 하드웨어 FSM이 자동 실행 */
dmaengine_submit(tx);
dma_async_issue_pending(chan);
/* → 하드웨어: IDLE → REQUEST → TRANSFER(반복) → DONE → IRQ */

MMIO와 PIO

MMIO에서는 주소 디코더가 물리 주소의 상위 비트를 해독하여 메모리 접근인지 장치 레지스터 접근인지 구분합니다. PIO는 별도의 I/O 주소 공간을 사용하며, x86의 in/out 명령이 이를 제어합니다.

/* MMIO: 메모리 매핑된 장치 레지스터 접근 */
void __iomem *base = ioremap(phys_addr, size);
writel(value, base + REG_OFFSET);      /* 주소 디코더가 장치 선택 */
u32 val = readl(base + REG_OFFSET);

/* PIO: I/O 포트 접근 (x86) */
outb(value, 0x3F8);   /* COM1 시리얼 포트 */
u8 data = inb(0x3F8);

메모리 배리어와 하드웨어 순서

현대 프로세서는 성능 최적화를 위해 명령의 실행 순서를 변경(Out-of-Order Execution)합니다. 이는 파이프라인(Pipeline)의 각 스테이지가 독립적인 조합/순차 논리회로로 구현되기 때문에 가능합니다. 그러나 장치 레지스터 접근에서는 순서가 중요합니다.

/* 메모리 배리어 — 하드웨어 순서 보장 명령 */
/* 장치 레지스터 쓰기 순서가 중요한 경우 */
writel(config_value, base + CONFIG_REG);  /* 1. 설정 쓰기 */
wmb();                                     /* 쓰기 배리어 */
writel(start_cmd, base + COMMAND_REG);     /* 2. 시작 명령 */
/* wmb()가 없으면 CPU가 2를 1보다 먼저 실행할 수 있음 */

/* x86: mfence/sfence/lfence 명령 */
/* ARM: dmb/dsb/isb 명령 */
/* 이 명령들은 파이프라인을 부분적으로 직렬화(Serialize) */

/* readl()/writel()은 이미 배리어를 포함 (ioremap의 속성에 따라) */
/* readl_relaxed()/writel_relaxed()는 배리어 없는 버전 */
u32 status;
do {
    status = readl_relaxed(base + STATUS_REG);
} while (!(status & DONE_BIT));
rmb();  /* 상태 확인 후 데이터 읽기 전 배리어 필요 */
data = readl_relaxed(base + DATA_REG);

파이프라인과 비순차 실행

CPU 파이프라인(Pipeline)은 명령 실행을 여러 단계(Fetch → Decode → Execute → Memory → Writeback)로 분할한 구조입니다. 각 단계가 독립적인 조합/순차 논리회로로 구현되며, 단계 사이에 파이프라인 레지스터(Pipeline Register, D 플립플롭 배열)가 있어 각 단계가 동시에 서로 다른 명령을 처리합니다.

비순차 실행(Out-of-Order Execution)은 데이터 의존성이 없는 명령의 실행 순서를 변경하여 파이프라인 중단(Stall)을 최소화합니다. 이를 위해 다음 하드웨어가 필요합니다:

• 예약 스테이션(Reservation Station) — 피연산자가 준비될 때까지 대기하는 FIFO 큐
• 재정렬 버퍼(ROB, Reorder Buffer) — 순서 복원을 위한 원형 버퍼 (시프트 레지스터 변형)
• 레지스터 리네이밍(Register Renaming) — 물리 레지스터 파일의 MUX/DEMUX를 통한 동적 매핑
• 분기 예측기(Branch Predictor) — FSM 기반 (2비트 포화 카운터가 가장 기본)

커널은 이러한 마이크로아키텍처를 직접 제어하지 않지만, 그 동작을 이해하고 활용합니다. likely()/unlikely() 매크로가 분기 예측기에 힌트를 주고, 메모리 배리어가 재정렬을 제한하며, perf stat이 파이프라인 효율(IPC, 캐시 미스율)을 측정합니다.

파이프라인 해저드(Pipeline Hazard)와 커널 코드 최적화:

Spectre/Meltdown 취약점은 비순차 실행(투기적 실행, Speculative Execution)의 부작용을 악용합니다. 분기 예측이 잘못되어 롤백된 명령이라도 캐시 상태를 변경하며, 이를 사이드 채널(Side Channel)로 활용하여 비밀 데이터를 추출할 수 있습니다. 커널의 대응책(KPTI, Retpoline, IBRS/IBPB)은 하드웨어 투기적 실행의 가시적 부작용을 차단합니다.

/* Spectre 대응: 간접 분기 예측 방어 */
/* retpoline — 간접 점프를 RET 명령으로 대체 */
/* → 분기 예측기(BTB)가 아닌 RSB(Return Stack Buffer) 사용 */
/* → RSB는 CALL/RET 쌍에만 반응하므로 공격자가 조작 불가 */

/* KPTI (Kernel Page Table Isolation) — Meltdown 대응 */
/* 커널/사용자 페이지 테이블 분리 → 투기적 실행으로도 */
/* 커널 메모리에 접근 불가 */

/* /sys/devices/system/cpu/vulnerabilities/ */
/* $ cat /sys/devices/system/cpu/vulnerabilities/spectre_v2 */
/* Mitigation: Retpoline, IBPB: conditional, IBRS_FW ... */

/* 파이프라인 효율 모니터링 — perf stat */
/* $ perf stat -e cycles,instructions,cache-misses ./workload */
/* 결과 예시: */
/*   1,000,000,000  cycles        */
/*   2,500,000,000  instructions  # IPC = 2.50 */
/*       5,000,000  cache-misses  */

/* IPC(Instructions Per Cycle)가 높을수록 파이프라인 효율 좋음 */
/* 이론적 최대: 슈퍼스칼라 폭 (4~8) */
/* 실제: 데이터 의존성, 캐시 미스, 분기 예측 실패로 감소 */

프로그래머블 로직 (Programmable Logic)

프로그래머블 로직 장치(PLD, Programmable Logic Device)는 제조 후에 논리 기능을 프로그래밍할 수 있는 반도체입니다. ASIC(Application-Specific IC)과 달리 현장에서 기능을 변경할 수 있어, 프로토타이핑과 소량 생산에 적합합니다.

PLD와 GAL

초기 PLD는 AND-OR 2단계 구조의 프로그래머블 배열로, SOP(Sum of Products) 형태의 부울 함수를 직접 구현했습니다. PAL(Programmable Array Logic)은 AND 배열만 프로그래밍 가능하고, PLA(Programmable Logic Array)는 AND와 OR 배열 모두 프로그래밍 가능합니다. GAL(Generic Array Logic)은 PAL에 출력 매크로셀(Output Macrocell)을 추가하여 레지스터 출력과 피드백을 지원합니다.

CPLD(Complex PLD)는 여러 PAL/GAL 블록을 하나의 칩에 집적하고, 프로그래밍 가능 인터커넥트로 연결한 것입니다. FPGA에 비해 구조가 단순하고 전파 지연이 예측 가능하여, 글루 로직(Glue Logic)이나 버스 인터페이스에 적합합니다. 비휘발성(Non-volatile) 구성 메모리를 사용하므로 전원 인가 즉시 동작합니다 (FPGA는 대부분 SRAM 기반으로 부팅 시 비트스트림 로드 필요).

FPGA 구조

FPGA(Field-Programmable Gate Array, 현장 프로그래머블 게이트 어레이)는 현대 프로그래머블 로직의 핵심입니다. 수만~수백만 개의 구성 가능 논리 블록(CLB, Configurable Logic Block)과 프로그래밍 가능 인터커넥트(Interconnect)로 구성됩니다.

LUT(Look-Up Table)이 FPGA의 핵심입니다. n-입력 LUT은 2ⁿ비트 SRAM으로 구현되며, 입력을 주소로 사용하여 진리표를 직접 참조합니다. 따라서 어떤 n-변수 부울 함수도 하나의 n-입력 LUT으로 구현할 수 있습니다. 현대 FPGA는 6-입력 LUT(64비트 SRAM)을 사용합니다.

FPGA와 ASIC의 비교:

FPGA 설계 흐름은 디지털 논리회로의 모든 개념을 종합합니다: HDL(Hardware Description Language)로 논리를 기술하면, 합성(Synthesis) 도구가 LUT/FF로 매핑하고, 배치 배선(Place & Route) 도구가 CLB와 인터커넥트를 할당합니다. 정적 타이밍 분석(STA, Static Timing Analysis)이 모든 경로의 셋업/홀드 시간 만족을 확인합니다.

타이밍 클로저(Timing Closure)는 FPGA 설계에서 가장 도전적인 단계입니다. 모든 조합 논리 경로가 클록 주기 내에 셋업 시간(t_su)을 만족해야 하며, 홀드 시간(t_h)도 보장되어야 합니다. 이 개념은 셋업 시간과 홀드 시간 섹션에서 다룬 것과 동일합니다. 임계 경로(Critical Path)가 클록 주기보다 길면 타이밍 위반이 발생하며, RTL 수정(파이프라인 단계 추가), 배치 제약 변경, 또는 클록 주파수 하향이 필요합니다. 커널 개발자가 FPGA 가속기의 최대 동작 주파수를 이해하거나, FPGA 기반 장치의 타이밍 관련 하드웨어 버그를 진단할 때 이 지식이 필수적입니다.

/* Verilog HDL 예시: 4비트 카운터 */
/* FPGA의 CLB 내 플립플롭과 가산기로 구현됨 */
module counter4(
    input        clk,
    input        rst,
    output reg [3:0] count
);
    always @(posedge clk or posedge rst)
        if (rst)
            count <= 4'b0000;
        else
            count <= count + 1;
endmodule
/* 합성 결과: 4개 D-FF + 4비트 가산기(LUT으로 구현) */

커널과 FPGA

리눅스 커널은 FPGA Manager 프레임워크를 제공하여 런타임에 FPGA를 재구성(Reconfiguration)할 수 있습니다.

/* drivers/fpga/ — FPGA Manager 프레임워크 */
struct fpga_manager {
    const char                  *name;
    struct device               dev;
    const struct fpga_manager_ops *mops;  /* write_init, write, write_complete */
    enum fpga_mgr_states       state;
};

/* FPGA 비트스트림 로드 */
fpga_mgr_load(mgr, &info);

/* FPGA 영역(Region)과 브리지(Bridge) */
/* fpga_region: FPGA의 재구성 가능 영역 */
/* fpga_bridge: CPU와 FPGA 간 인터페이스 (AXI 등) */

/* 디바이스 트리 바인딩 예시 */
/* fpga_region0: fpga-region@0 { */
/*     compatible = "fpga-region"; */
/*     fpga-mgr = <&fpga_mgr0>; */
/*     fpga-bridges = <&fpga_bridge0>; */
/* }; */

FPGA의 커널 활용 사례:

• 네트워크 가속 — SmartNIC에서 패킷 처리 오프로드 (XDP/eBPF 하드웨어 가속)
• 스토리지 가속 — NVMe 컨트롤러, 압축/암호화 엔진
• DMA 엔진 — FPGA에 구현된 커스텀 DMA 컨트롤러를 커널 DMA 엔진 프레임워크에 연결
• AWS F1 인스턴스 — 클라우드에서 FPGA 가속기를 커널 드라이버로 접근

FPGA SmartNIC과 DPU — 현대 데이터센터에서 FPGA 기반 SmartNIC(Xilinx Alveo, Intel Agilex 등)이 네트워크 데이터플레인 처리를 CPU에서 오프로드합니다. 커널의 TC(Traffic Control) 오프로드, XDP 하드웨어 오프로드, OVS(Open vSwitch) 오프로드가 이를 활용하며, devlink 프레임워크가 SmartNIC의 기능을 관리합니다.

/* SmartNIC devlink 관리 인터페이스 */
/* $ devlink dev show */
/* pci/0000:03:00.0: */
/*   driver nfp  fw.mgmt 0.23.0.0  fw.app nic */

/* TC 오프로드 — FPGA가 패킷 분류/포워딩 수행 */
/* $ tc qdisc add dev eth0 clsact */
/* $ tc filter add dev eth0 ingress protocol ip flower skip_hw ... */
/* skip_hw → CPU에서만, skip_sw → FPGA에서만 실행 */

/* FPGA Manager sysfs 인터페이스 */
/* /sys/class/fpga_manager/fpga0/name → FPGA 디바이스 이름 */
/* /sys/class/fpga_manager/fpga0/state → operating, unknown 등 */

/* fpga_manager_ops — FPGA Manager 드라이버 구현 */
static const struct fpga_manager_ops my_fpga_ops = {
    .state          = my_fpga_state,       /* 현재 상태 조회 */
    .write_init     = my_fpga_write_init,  /* 재구성 시작 준비 */
    .write          = my_fpga_write,       /* 비트스트림 데이터 전송 */
    .write_complete = my_fpga_write_complete, /* 재구성 완료 처리 */
};

/* FPGA 비트스트림 로드 예시 */
/* Device Tree Overlay를 통한 동적 재구성 */
struct fpga_image_info *info;
info = fpga_image_info_alloc(dev);
info->firmware_name = "design.rbf";  /* FPGA 비트스트림 파일 */
info->flags = FPGA_MGR_PARTIAL_RECONFIG; /* 부분 재구성 */

/* 재구성 수행 */
ret = fpga_region_program_fpga(region);
if (ret)
    dev_err(dev, "FPGA programming failed: %d\n", ret);

/* 재구성 완료 후 FPGA 내부 로직이 새 기능으로 동작 시작 */
/* → 해당 FPGA IP의 장치 드라이버가 probe됨 */

부분 재구성(Partial Reconfiguration)은 FPGA의 일부 영역만 변경하는 기술입니다. 시스템 동작 중에 기능을 교체할 수 있어, 하나의 FPGA로 시간에 따라 다른 가속기를 운용할 수 있습니다. 이는 칩 내부의 "가상화"로 볼 수 있으며, 커널의 FPGA 브리지 프레임워크가 재구성 중 안전한 격리를 보장합니다.

하드웨어 디버깅과 JTAG

JTAG(Joint Test Action Group, IEEE 1149.1)은 원래 인쇄 회로 기판(PCB)의 제조 결함을 검출하기 위한 경계 스캔(Boundary Scan) 표준으로 개발되었습니다. 현재는 칩 내부 디버깅, 플래시 프로그래밍, FPGA 비트스트림 로딩 등 하드웨어 개발의 핵심 인터페이스로 사용됩니다.

JTAG의 핵심 구성 요소:

• TAP (Test Access Port) — TCK(클록), TMS(모드 선택), TDI(데이터 입력), TDO(데이터 출력), nTRST(리셋) 5개 신호선
• TAP 컨트롤러 — 16-상태 FSM(유한 상태 머신)으로, TMS 신호에 따라 상태 천이. 이 페이지의 유한 상태 머신 섹션에서 다룬 FSM의 실제 응용입니다
• 명령 레지스터(IR) — 수행할 동작을 선택하는 시프트 레지스터
• 데이터 레지스터(DR) — BSR(Boundary Scan Register), BYPASS, IDCODE 등 여러 시프트 레지스터 중 IR이 선택한 레지스터에 데이터를 시프트

경계 스캔의 동작 원리: 칩의 모든 I/O 핀에 직렬로 연결된 시프트 레지스터(BSR) 셀을 삽입합니다. 테스트 모드에서 외부에서 TDI로 데이터를 시프트하여 각 핀의 출력을 제어하거나, 핀의 입력 값을 TDO로 읽어낼 수 있습니다. 이는 이 페이지의 시프트 레지스터 섹션에서 다룬 직렬-병렬 변환의 직접적인 응용입니다.

커널 디버깅과의 연결:

• KGDB/KDB — 커널의 소프트웨어 디버거. GDB가 시리얼 포트나 네트워크를 통해 커널에 접속하여 브레이크포인트를 설정하고 변수를 검사합니다
• 하드웨어 브레이크포인트 — CPU의 디버그 레지스터(x86: DR0~DR7, ARM: DBGBCR/DBGBVR)를 사용하여 특정 주소 접근 시 CPU를 정지시킵니다. JTAG 디버거는 이 레지스터를 직접 제어할 수 있어, 커널이 완전히 멈춘 상태(커널 패닉, 부트 초기)에서도 디버깅이 가능합니다
• JTAG 디버거(OpenOCD, J-Link) — 임베디드 리눅스 개발에서 부트로더부터 커널까지 전체 부팅 과정을 단계별로 추적할 수 있습니다. openocd가 JTAG 하드웨어를 제어하고, GDB가 여기에 연결됩니다

/* 하드웨어 브레이크포인트 설정 — arch/x86/kernel/hw_breakpoint.c */
/* x86 디버그 레지스터를 통해 JTAG 없이도 하드웨어 브레이크포인트 사용 가능 */
struct perf_event *bp;
struct perf_event_attr attr;

hw_breakpoint_init(&attr);
attr.bp_addr = (unsigned long)target_address;
attr.bp_len  = HW_BREAKPOINT_LEN_4;      /* 4바이트 감시 */
attr.bp_type = HW_BREAKPOINT_W;           /* 쓰기 감시 */

/* 해당 주소에 쓰기 발생 시 콜백 호출 */
bp = register_wide_hw_breakpoint(&attr, handler, NULL);

/* KGDB와 JTAG 모두 동일한 CPU 디버그 레지스터를 사용 */
/* → JTAG는 외부에서, KGDB는 소프트웨어에서 접근 */

참고자료

디지털 논리와 커널 개발 요약

이 페이지에서 다룬 디지털 논리회로 개념과 커널 서브시스템의 대응 관계를 정리합니다.

커널 개발자가 디지털 논리를 이해하면 얻을 수 있는 구체적 이점:

• 하드웨어 버그 진단 — 타이밍 위반, 메타안정성, 글리치로 인한 간헐적 오류를 인식
• 드라이버 최적화 — MMIO 접근 패턴, 배리어 필요성, DMA 설정을 물리적으로 이해
• 성능 분석 — IPC, 캐시 미스, 분기 예측 실패의 하드웨어 원인을 파악
• 보안 — Spectre/Meltdown 같은 마이크로아키텍처 취약점의 근본 원인 이해
• 이식 — 새로운 아키텍처로의 커널 포팅 시 하드웨어 차이점을 정확히 파악
• 디바이스 트리 — SoC의 디코더, MUX, 클록 트리 구조를 정확히 기술
• 전력 관리 — 클록 게이팅, 파워 게이팅의 물리적 원리를 이해하고 커널 PM 프레임워크 활용
• 실시간 시스템 — 인터럽트 지연, DMA 전송 시간, 버스 중재 시간의 하드웨어 원인 파악

교과서 및 참고 문헌

• M. Morris Mano, Michael D. Ciletti — Digital Design: With an Introduction to the Verilog HDL, VHDL, and SystemVerilog, 6th Edition, Pearson
• John F. Wakerly — Digital Design: Principles and Practices, 5th Edition, Pearson
• David Harris, Sarah Harris — Digital Design and Computer Architecture, 2nd Edition, Morgan Kaufmann
• Neil Weste, David Harris — CMOS VLSI Design: A Circuits and Systems Perspective, 4th Edition, Addison-Wesley
• Intel Corporation — Intel 64 and IA-32 Architectures Software Developer's Manual, Vol. 3 (System Programming Guide)
• ARM Limited — ARM Architecture Reference Manual (ARMv8-A, ARMv9)
• ARM Limited — AMBA AXI and ACE Protocol Specification (IHI 0022)

온라인 자료

• Linux Kernel Documentation — 공식 커널 문서
• Boolean Algebra — Wikipedia — 부울 대수 이론
• Flip-flop (electronics) — Wikipedia — 플립플롭 회로 상세
• CMOS — Wikipedia — CMOS 기술 개요
• Linux FPGA Framework — 커널 FPGA Manager API
• JTAG — Wikipedia — IEEE 1149.1 경계 스캔 표준
• Cache — Wikipedia — 캐시 메모리 구조와 교체 알고리즘
• Finite-state machine — Wikipedia — 유한 상태 머신 이론
• Gray code — Wikipedia — 그레이 코드와 응용
• Error correction code — Wikipedia — 오류 정정 코드 이론
• Carry-lookahead adder — Wikipedia — 올림 예측 가산기
• Phase-locked loop — Wikipedia — PLL 회로 이론
• LFSR — Wikipedia — 선형 궤환 시프트 레지스터
• GPIO 서브시스템 문서 — General Purpose Input/Output (kernel.org)
• 공통 클록 프레임워크 — The Common Clk Framework (kernel.org)
• 성능 카운터(PMC) 문서 — perf subsystem (kernel.org)
• EDAC (오류 감지/정정) 문서 — Error Detection And Correction (kernel.org)
• CRC32 구현 소스 — lib/crc32.c (Bootlin Elixir)
• 비트 연산 헤더 — include/linux/bitops.h (Bootlin Elixir)
• 클록 드라이버 소스 — drivers/clk/ (Bootlin Elixir)
• FPGA Manager 프레임워크 소개 — FPGA Manager framework (LWN.net)
• 메모리 배리어의 이해 — A formal kernel memory-ordering model (LWN.net)
• 캐시/TLB 플러시 인터페이스 — Cache and TLB Flushing (kernel.org)
• David Patterson, John Hennessy — Computer Organization and Design, 6th Edition, Morgan Kaufmann (컴퓨터 구조와 디지털 논리 설계)