디지털 논리회로 (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는 가산기를 재활용(Recycling)하여 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)

산술 회로 — 곱셈·나눗셈·FPU

기본적인 가산기와 감산기를 넘어, 실제 프로세서는 곱셈, 나눗셈, 부동소수점 연산을 위한 복잡한 산술 회로를 포함합니다.

배열 곱셈기 (Array Multiplier)

배열 곱셈기(Array Multiplier)는 부분곱(Partial Product)을 AND 게이트로 생성하고, 가산기 배열로 합산하는 구조입니다.

1. 부분곱 생성: 피승수의 각 비트와 승수의 각 비트를 AND하여 n² 개의 부분곱 생성
2. 부분곱 정렬: 각 행은 승수 비트 위치만큼 좌측 시프트
3. 합산: CSA(Carry-Save Adder) 배열로 캐리 전파를 줄이고 최종 RCA로 합산

4×4 배열 곱셈기의 지연은 O(2n) 게이트 지연입니다. 대규모 곱셈에서는 월리스 트리(Wallace Tree) 등이 사용됩니다.

부스 곱셈기 (Booth's Algorithm)

부스 알고리즘은 연속된 1의 구간을 뺄셈과 덧셈으로 대체하여 부분곱을 줄이는 기법입니다.

수정 부스(Radix-4) 인코딩은 3비트 그룹을 검사하여 부분곱 행을 절반으로 줄입니다. 실제 CPU의 하드웨어 곱셈기가 이 방식을 사용합니다.

나눗셈기 (Divider)

나눗셈은 본질적으로 순차적(Sequential)이어서 곱셈보다 훨씬 느립니다.

• 복원 나눗셈(Restoring): 제수를 빼고, 결과가 음수이면 복원(다시 더함)
• 비복원 나눗셈(Non-Restoring): 복원 단계를 생략하고 부호에 따라 덧셈/뺄셈 교대
• SRT 나눗셈: 룩업 테이블로 한 번에 여러 비트 몫을 결정. 실제 CPU에서 사용

/* include/asm-generic/div64.h – 효율적 64비트 나눗셈 */
#define do_div(n, base) ({                    \
    uint32_t __base = (base);               \
    uint32_t __rem;                          \
    __rem = ((uint64_t)(n)) % __base;        \
    (n) = ((uint64_t)(n)) / __base;          \
    __rem;                                    \
})

/* 2의 거듭제곱 나눗셈은 시프트로 대체됨 */
/* page_nr = addr >> PAGE_SHIFT; (÷4096 → >>12) */

부동소수점 유닛 기초 (FPU)

FPU 파이프라인(Pipeline) 단계: 언패킹 → 지수 정렬 → 연산 → 정규화 → 반올림 → 패킹

월리스 트리 곱셈기 (Wallace Tree Multiplier)

월리스 트리(Wallace Tree) 곱셈기는 배열 곱셈기의 선형 감소 구조를 트리 구조로 개선하여 지연 시간을 O(log N)으로 줄이는 고속 곱셈 방식입니다. 동작은 3단계로 나뉩니다:

1. 부분곱 생성(Partial Product Generation): 배열 곱셈기와 동일하게 피승수와 승수의 각 비트를 AND하여 n개 행의 부분곱을 생성합니다. 수정 부스(Radix-4) 인코딩을 적용하면 부분곱 행 수를 절반으로 줄일 수 있습니다.
2. 감소 단계(Reduction Stage): 캐리 세이브 가산기(CSA, Carry-Save Adder)를 사용하여 3개의 부분곱 행을 2개의 행(합 + 캐리)으로 줄입니다. 이 과정을 부분곱 행이 2개만 남을 때까지 재귀적으로 반복합니다. 각 CSA 레벨은 행의 수를 2/3로 감소시키므로, 전체 감소 단계는 O(log₃/₂ N) ≈ O(log N)의 깊이를 가집니다.
3. 최종 합산(Final Addition): 남은 2개의 행을 올림 예측 가산기(CLA) 또는 올림 선택 가산기로 최종 합산합니다.

부동소수점 특수 케이스와 반올림

IEEE 754 부동소수점 표현에는 정규화 수 이외에도 다양한 특수 케이스가 존재하며, 연산 결과의 정밀도는 반올림 모드에 의해 결정됩니다.

비정규화 수 (Denormalized/Subnormal Numbers)

지수가 모두 0이고 가수가 0이 아닌 경우, 비정규화 수(Subnormal Number)로 해석됩니다. 정규화 수의 최솟값보다 더 작은 값을 표현하여 점진적 언더플로(Gradual Underflow)를 구현합니다.

• 정규화 수: (-1)ˢ × 1.mantissa × 2^(exp - bias) — 숨겨진 1(Hidden Bit)이 존재합니다
• 비정규화 수: (-1)ˢ × 0.mantissa × 2^(1 - bias) — 숨겨진 1이 없습니다
• double 기준 최소 비정규화 값: ≈ 4.94 × 10⁻³²⁴, 최소 정규화 값: ≈ 2.22 × 10⁻³⁰⁸
• 하드웨어에서 비정규화 연산은 일반적으로 마이크로코드 처리되어 정규화 연산의 10~100배 느립니다

반올림 모드 (Rounding Modes)

특수값 처리

NaN 전파 규칙: QNaN은 연산 시 조용히 전파되지만, SNaN은 예외(Exception)를 발생시킵니다. IEEE 754-2019에서는 minimumNumber/maximumNumber 연산이 추가되어 NaN 인자를 무시하고 유효한 값을 반환하도록 개선되었습니다.

순차 논리회로 (Sequential Logic)

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

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

순차 회로의 분류: 동기식 vs 비동기식

순차 논리회로는 클록 신호의 사용 여부에 따라 두 가지로 분류됩니다. 동기식 순차 회로(Synchronous Sequential Circuit)는 모든 상태 변화가 클록 신호에 동기화되어 발생합니다. 클록 에지에서만 플립플롭의 출력이 변경되므로 타이밍 분석이 용이하고, 현대 디지털 시스템의 표준이 되었습니다. 반면 비동기식 순차 회로(Asynchronous Sequential Circuit)는 클록 없이 입력 신호의 변화만으로 상태가 즉시 변경됩니다. 비동기식은 타이밍 분석이 복잡하지만, 낮은 지연(Latency)과 저전력이라는 장점이 있으며, 중요한 상태 신호(인터럽트, 리셋 등)에만 제한적으로 사용됩니다.

동기식 설계에서는 모든 플립플롭이 동일한 클록 신호에 의해 구동됩니다. 이 클록은 전역 클록(Global Clock) 또는 시스템 클록(System Clock)이라고 불리며, PCB 전체 또는 칩 전체에 분배됩니다. 클록 주파수가 높을수록 더 많은 연산을 빠르게 수행할 수 있지만, 클록 분배 네트워크의 부하와 전류 소비도 함께 증가합니다. 최신 프로세서에서는 수십억 개의 트랜지스터가 수천 개의 클록 도메인에 분배된 클록 신호를 사용합니다.

플립플롭의 타이밍 파라미터

플립플롭의 정확한 동작을 이해하기 위해서는 타이밍 파라미터를 반드시 이해해야 합니다. 이러한 파라미터들은 클록 에지에서 데이터가 샘플링되는 시점을 결정하며, 타이밍 분석(Timing Analysis)의 기초가 됩니다.

셋업 시간과 홀드 시간을 함께하여 타이밍 윈도우(Timing Window)라고 합니다. 이 윈도우 내에서 입력 데이터는 안정한 상태를 유지해야 하며, 이를 위반하면 메타스테이블(Metastable) 상태가 발생할 수 있습니다. 메타스테이블 상태에서는 출력이 0도 1도 아닌 중간 전압 수준을 유지하며, 최종적으로는 0 또는 1로 수렴하지만, 수렴 시간이 매우 길어 후속 회로에 타이밍 위반을 유발할 수 있습니다.

/* 커널에서의 타이밍 제약 예시: 레지스터 접근 순서 */
/* 특정 하드웨어 레지스터는 특정 순서로 접근해야 타이밍 제약을 만족 */

/* 올바른 순서: 데이터 쓴 후 상태 확인 */
writel(data, regs + DATA_REG);    /* 데이터 쓰기 */
writel(CTRL_START, regs + CTRL_REG);  /* 시작 신호 */
/* 이 사이의 지연이 tSU 미달이면 동작 불확정 */

/* 해결: 레지스터 간 의존성 명시적 동기화 */
void hw_sequence(void __iomem *base, u32 data)
{
    /* 첫 번째 쓰기가 완료될 때까지 대기 (메모리 배리어) */
    writel(data, base + DATA_REG);
    wmb();  /* 쓰기 메모리 배리어 - 하드웨어 완료 대기 */
    
    /* 이제 제어 쓰기 - 데이터가 안정한 것을 보장 */
    writel(CTRL_START, base + CTRL_REG);
}

상태 머신 (Finite State Machine, FSM)

상태 머신(Finite State Machine 또는 Finite State Automaton)은 순차 논리회로를 추상화하는 가장 강력한 모델입니다. FSM은 유한한 상태(Finite States)의 집합, 현재 상태(Current State), 입력에 따른 상태 전이(State Transition), 그리고 각 상태에서의 출력으로 구성됩니다. 디지털 시스템에서 FSM은 제어 로직, 프로토콜 처리, 시퀀서(Sequencer) 등 거의 모든 복잡한 순차 동작을 기술하는 데 사용됩니다.

FSM은 크게 두 가지 유형으로 분류됩니다. mealy 머신(Mealy Machine)은 현재 상태와 입력을 모두 조합하여 출력을 생성합니다. 출력이 입력에 즉시 의존하므로 동일한 상태에서도 입력에 따라 다른 출력이 나올 수 있습니다. Moore 머신(Moore Machine)은 현재 상태에만 의존하여 출력을 생성합니다. 출력은 클록 에지에서만 변경되므로 출력이 입력보다 최소 한 클록 사이클 늦게 반영됩니다. 일반적으로 Moore 머신이 타이밍 분석이 더 단순하고 디버깅이 용이하여 더 선호됩니다.

FSM의 설계는 먼저 상태 다이어그램(State Diagram)을 그리고, 이를 상태 테이블(State Table)로 변환한 후, 상태 할당(State Assignment)을 수행하고, 조합 논리와 플립플롭으로 구현하는 순서로 진행됩니다. 상태 할당은 Gray 코드 할당(Gray Code Assignment)을 사용하여 인접 상태 간에는 한 비트만 변경되도록 하면 플립플롭 간 전이 시 글리치(Glitch)를 줄일 수 있습니다.

// FSM 예시: 2비트 업 카운터 (Moore 머신)
module counter_fsm (
    input  logic       clk,
    input  logic       rst_n,
    input  logic       enable,
    output logic [1:0] count,
    output logic       overflow
);

    typedef enum logic [1:0] {
        IDLE  = 2'b00,
        COUNT1 = 2'b01,
        COUNT2 = 2'b10,
        COUNT3 = 2'b11
    } state_t;
    
    state_t state, next_state;

    // 상태 레지스터 (순차 논리)
    always_ff @(posedge clk or negedge rst_n) begin
        if (!rst_n)
            state <= IDLE;
        else
            state <= next_state;
    end

    // 다음 상태 조합 논리
    always_comb begin
        if (!enable) begin
            next_state = state;
        end else begin
            case (state)
                IDLE:    next_state = COUNT1;
                COUNT1:  next_state = COUNT2;
                COUNT2:  next_state = COUNT3;
                COUNT3:  next_state = IDLE;  // 카운트 완료 후 복귀
                default: next_state = IDLE;
            endcase
        end
    end

    // 출력 조합 논리 (Moore 출력 - 상태만으로 결정)
    assign count = state;
    assign overflow = (state == COUNT3) && enable;

endmodule

카운터 설계와 응용

카운터(Counter)는 가장 널리 사용되는 순차 논리 회로 중 하나로, 특정 주파수로 펄스를 세거나, 시퀀스를 생성하거나, 타이밍을 생성하는 데 사용됩니다. 카운터는 기본적으로 클록 신호를 분주(Divide)하여 원하는 주파수의 출력을 생성하며, 이 원리는 디지털 시계, 타이머, PWM(Pulse Width Modulation) 생성기 등 다양한 시스템에 응용됩니다.

카운터의 유형은 다양합니다. 업 카운터(Up Counter)는 0에서부터 지정된 최대값까지 순차적으로 증가합니다. 다운 카운터(Down Counter)는 그 반대로 동작합니다. 업다운 카운터(Up-Down Counter)는 방향 신호에 따라 증가 또는 감소할 수 있습니다. 모듈러 카운터(Modulo-n Counter)는 n개 상태를 순환한 후 초기 상태로 돌아갑니다. 이는 n진법 카운터로도 볼 수 있습니다.

// 매개변수화된 범용 카운터 모듈
module universal_counter #(
    parameter WIDTH = 8,  /* 카운터 비트 수 */
    parameter MAX_VAL = 255  /* 카운터 최대값 */
) (
    input               clk,
    input               rst_n,
    input               enable,
    input               direction,  /* 1: up, 0: down */
    input               load,      /* 초기값 로드 */
    input  [WIDTH-1:0] load_value,
    output logic [WIDTH-1:0] count,
    output logic           overflow
);

    always_ff @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            count <= '0;
            overflow <= 1'b0;
        end else if (load) begin
            count <= load_value;
            overflow <= 1'b0;
        end else if (enable) begin
            if (direction) begin  /* 업 카운트 */
                if (count >= MAX_VAL) begin
                    count <= '0;
                    overflow <= 1'b1;
                end else begin
                    count <= count + 1'b1;
                    overflow <= 1'b0;
                end
            end else begin  /* 다운 카운트 */
                if (count == 0) begin
                    count <= MAX_VAL;
                    overflow <= 1'b1;
                end else begin
                    count <= count - 1'b1;
                    overflow <= 1'b0;
                end
            end
        end
    end

endmodule

시프트 레지스터

시프트 레지스터(Shift Register)는 데이터를 왼쪽 또는 오른쪽으로 한 비트씩 이동시키는 순차 논리 회로입니다. 직렬-병렬 변환(Serial-to-Parallel Conversion), 병렬-직렬 변환(Parallel-to-Serial Conversion), 시프트 연산, 지연 라인(Delay Line) 구현, 그리고 심플한 시프트-register 기반 FIFO(First-In-First-Out) 메모리 등에 사용됩니다.

시프트 레지스터는 기본적으로 체인처럼 연결된 D 플립플롭으로 구성됩니다. 각 클록 에지에서 각 플립플롭의 출력이 다음 플립플롭의 입력으로 전달되며, 가장 왼쪽의 플립플롭은 새로운 데이터를 입력받고, 가장 오른쪽의 플립플롭은 데이터를 출력합니다. 이 구조는 간단하지만 효과적으로 직렬 데이터 스트림을 처리할 수 있습니다.

래치와 플립플롭: 핵심 차이점

래치(Latch)와 플립플롭(Flip-Flop)은 둘 다 이진 상태를 저장하는 메모리 소자이지만, 트리거 방식에서 근본적인 차이가 있습니다. 이 차이는 디지털 시스템의 안정성과 타이밍 분석에 큰 영향을 미치므로, 설계자는 반드시 둘의 차이를 명확히 이해해야 합니다.

래치는 레벨 트리거(Level-Triggered) 방식으로 동작합니다. 클록(또는 인에이블) 신호가 특정 레벨(High 또는 Low)인 동안에만 입력을 반영합니다. 클록이 활성 상태인 동안은 입력 신호의 모든 변화가 출력에 즉시 반영됩니다. 이 때문에 래치는 조합 논리 회로와 유사하게 입력이 변경되면 출력이 즉각 변경될 수 있어, 원치 않는_glitch가 전파될 수 있습니다.

플립플롭은 에지 트리거(Edge-Triggered) 방식으로 동작합니다. 클록 신호의 상승 에지 또는 하강 에지에서만 입력을 샘플링하여 출력에 반영합니다. 에지 사이에는 입력이 어떻게 변경되든 출력은 변하지 않습니다. 이 deterministic한 동작으로 인해 타이밍 분석이 훨씬 용이하고, 데이터 무결성이 보장됩니다.

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) 스케줄러의 하드웨어 구현에 사용됩니다.

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

시프트 레지스터 유형

시프트 레지스터는 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)에 사용됩니다.
• 해시 함수 — 해시 테이블(Hash Table)의 분산(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;
}

레지스터 전송 수준 설계

레지스터 전송 수준(RTL, Register Transfer Level) 설계는 디지털 시스템을 레지스터 간의 데이터 흐름과 변환으로 기술하는 추상화 수준입니다.

데이터패스와 제어 유닛

모든 디지털 시스템은 데이터패스(Datapath)와 제어 유닛(Control Unit)으로 나뉩니다. 데이터패스는 레지스터 파일, ALU, MUX, 버스 등으로 구성되고, 제어 유닛은 이들의 동작을 지시합니다.

현대 x86 CPU는 혼합 방식을 사용합니다: 간단한 명령어(ADD, MOV)는 하드와이어드로, 복잡한 명령어(REP MOVSB, CPUID)는 마이크로코드 ROM으로 처리합니다.

마이크로연산 (Micro-operations)

마이크로연산은 하드웨어가 한 클록 사이클에 수행할 수 있는 기본 동작 단위입니다.

ADD R1, R2, R3 분해: 인출(MAR←PC, IR←M[MAR], PC←PC+4) → 디코드(A←R2, B←R3) → 실행(R1←A+B)

ASM 차트 (Algorithmic State Machine)

ASM 차트의 3가지 요소: 상태 박스(직사각형), 판단 박스(마름모), 조건 출력 박스(둥근 직사각형).

간단한 프로세서 설계

프로세서의 핵심은 인출-디코드-실행(Fetch-Decode-Execute) 사이클을 반복하는 하드웨어 FSM입니다.

파이프라인 해저드와 커널

• 데이터 해저드: 미완료 결과를 후속 명령어가 필요로 함 → 포워딩/스톨
• 제어 해저드: 분기 결과를 모르고 다음 명령어 인출 → 분기 예측
• 구조적 해저드: 동일 하드웨어 자원 충돌 → 자원 복제

/* 메모리 배리어 — 파이프라인/OoO 실행에 의한 재배치 방지 */
#define barrier() __asm__ __volatile__("" ::: "memory")
/* 컴파일러 배리어: 컴파일러의 명령어 재배치를 방지 */

/* 하드웨어 배리어: CPU 파이프라인의 메모리 순서 재배치 방지 */
WRITE_ONCE(data, value);
smp_wmb();            /* data 쓰기가 flag 쓰기보다 먼저 관찰되도록 보장 */
WRITE_ONCE(flag, 1);

데이터패스 설계 패턴

디지털 시스템의 데이터패스는 연산의 성격에 따라 다양한 구조적 패턴으로 설계됩니다. 핵심은 성능(처리량, 지연 시간)과 자원 사용(면적, 전력) 사이의 균형입니다.

멀티사이클 연산

나눗셈기, 제곱근 계산기 등 본질적으로 순차적인 연산은 여러 클록 사이클에 걸쳐 수행됩니다. 이러한 연산의 데이터패스 구성 요소는 다음과 같습니다:

• 누산기(Accumulator): 매 사이클의 중간 결과를 저장하는 레지스터입니다
• 카운터: 반복 횟수를 추적하여 완료 시점을 결정합니다
• 상태 레지스터: 부호, 오버플로 등 조건 정보를 유지합니다
• 완료 신호(done): 제어 유닛에 연산 완료를 알립니다

SRT 나눗셈기는 사이클당 1~2비트의 몫을 결정하며, 64비트 나눗셈에 32~64 사이클이 필요합니다. 제곱근도 유사한 반복 구조를 사용하며, Newton-Raphson 근사법을 하드웨어로 구현하기도 합니다.

자원 공유 (Resource Sharing)

동시에 사용되지 않는 연산기를 시분할(Time-Multiplexing)하여 면적을 절약하는 기법입니다. 하나의 ALU를 여러 연산에 공유하는 것이 대표적인 예입니다:

• MUX 기반 공유: 입력 MUX가 현재 사이클의 피연산자를 선택하고, 출력 DEMUX가 결과를 올바른 목적지로 전달합니다
• 제어 유닛 역할: 어떤 사이클에 어떤 연산이 ALU를 사용할지 스케줄링합니다
• 트레이드오프: MUX/DEMUX 추가 면적 vs. 연산기 복제 면적. 연산기가 클수록(곱셈기, FPU) 공유의 이점이 큽니다

합성 도구는 상호 배타적(Mutually Exclusive) 연산을 자동으로 감지하여 자원 공유를 수행하지만, RTL 코딩 스타일(Coding Style)에 따라 공유가 불가능할 수 있으므로 설계자의 주의가 필요합니다.

파이프라인 데이터패스

긴 조합 논리 경로에 레지스터를 삽입하여 처리량을 높이는 기법입니다. 파이프라인 해저드(Hazard) 처리가 핵심 과제입니다:

• 데이터 해저드: 포워딩(Forwarding/Bypassing) 경로를 추가하여 파이프라인 스톨을 최소화합니다
• 제어 해저드: 분기 예측기(Branch Predictor)를 사용하여 파이프라인 플러시(Flush) 빈도를 줄입니다
• 파이프라인 지연: 스테이지 수가 많을수록 처리량은 증가하지만, 단일 연산의 지연 시간(지연)이 증가하고 해저드 페널티도 커집니다

제어 유닛 설계

제어 유닛(Control Unit)은 데이터패스의 동작을 지시하는 두뇌 역할을 합니다. 구현 방식에 따라 성능과 유연성이 크게 달라집니다.

하드와이어드 (Hardwired) 제어

조합 논리 회로와 FSM으로 제어 신호를 직접 생성하는 방식입니다:

• 구조: 현재 상태와 입력(opcode, 조건 플래그)을 조합하여 다음 상태와 제어 신호를 결정합니다
• 장점: 전파 지연이 짧아 고속 동작이 가능합니다. RISC 프로세서가 이 방식을 선호합니다
• 단점: 명령어 세트 변경 시 논리 회로 전체를 재설계해야 합니다. 복잡한 명령어의 제어 로직이 매우 복잡해집니다

마이크로코드 (Microcode) 제어

ROM(또는 PLA)에 저장된 마이크로명령어(Microinstruction) 시퀀스로 제어 신호를 생성하는 방식입니다:

• 수평 마이크로코드: 각 비트가 하나의 제어 신호에 직접 대응합니다. 디코딩이 불필요하여 빠르지만, 마이크로명령어의 폭이 넓습니다
• 수직 마이크로코드: 인코딩된 필드를 디코더로 해석합니다. 마이크로명령어 폭은 좁지만, 디코딩 지연이 추가됩니다
• 장점: 마이크로코드 ROM만 수정하면 명령어 동작을 변경할 수 있습니다. 복잡한 CISC 명령어 구현에 적합합니다
• 현대 x86: CPUID, REP MOVSB, XSAVE 등 복잡한 명령어는 마이크로코드로 구현되며, Intel은 microcode_intel 모듈을 통해 런타임 마이크로코드 업데이트를 지원합니다

ASM 차트 → RTL 변환

ASM(Algorithmic State Machine) 차트를 RTL로 변환하는 체계적인 규칙은 다음과 같습니다:

1개의 always @(posedge clk) 블록으로 상태 레지스터를, 1~2개의 always @(*) 블록으로 다음 상태 로직과 출력 로직을 기술하는 2~3 프로세스(Process) FSM 코딩 스타일이 가장 보편적입니다.

메모리 소자 (Memory Elements)

메모리 소자(Memory Element)는 데이터를 저장하고 유지하는 회로입니다. 플립플롭에서 발전한 레지스터와 대용량 저장을 위한 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)을 도입하여 대역폭(Bandwidth)을 더 향상시켰습니다.

리프레시는 모든 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)은 프리차지 + 활성화 지연이 추가됩니다. 커널의 메모리 할당자(Memory Allocator)가 연속 물리 페이지를 할당하면 행 적중률이 높아집니다.

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

ROM 유형 비교

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

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

버스 유형과 역할

직렬 vs 병렬 버스

역사적으로 병렬 버스가 먼저 사용되었지만, 현대 고속 인터커넥트는 대부분 직렬 버스입니다. 이유는 신호 간 타이밍 스큐(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)를 사용하여 병렬 데이터를 직렬화(Serialization)하고, 수신 측에서 클록 복원(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) 등의 토폴로지(Topology)가 사용됩니다.

Intel의 링 버스와 메시 인터커넥트(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)입니다. 플립플롭의 에지 트리거, 데이터 전송 타이밍, 파이프라인 스테이지 전환이 모두 클록에 동기화됩니다.

셋업 시간과 홀드 시간

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

메타안정성 (Metastability)

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

클록 트리 분배

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

클록 스큐(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 주파수 변경에 지연이 있는 물리적 이유입니다.

타이밍 분석 (Advanced Timing Analysis)

디지털 회로가 올바르게 동작하려면 모든 신호가 정해진 시간 안에 도착해야 합니다. 이 절에서는 임계 경로(Critical Path), 슬랙(Slack), 정적 타이밍 분석(Static Timing Analysis) 등 타이밍 검증의 핵심 개념을 다룹니다.

임계 경로 분석 (Critical Path Analysis)

임계 경로(Critical Path)란 두 순차 소자(플립플롭) 사이에서 가장 긴 조합 논리 지연을 갖는 경로를 말합니다. 회로의 최대 동작 주파수는 이 임계 경로의 지연에 의해 결정됩니다.

최대 동작 주파수는 다음 공식으로 계산합니다:

f_max = 1 / (t_cq + t_comb_max + t_su)

t_cq       : 클록-투-출력 지연 (Clock-to-Q delay) — 플립플롭 출력이 유효해지는 시간
t_comb_max : 최대 조합 논리 지연 — 가장 긴 경로의 전파 지연
t_su       : 셋업 시간 (Setup time) — 다음 플립플롭이 데이터를 안정적으로 캡처하기 위한 최소 시간

임계 경로를 줄이는 주요 기법은 다음과 같습니다:

• 논리 최적화(Logic Optimization): 불 대수 간소화, 공통 부분식 추출, 리타이밍을 통해 조합 논리의 단계 수를 줄입니다.
• 파이프라이닝(Pipelining): 긴 조합 논리 사이에 플립플롭을 삽입하여 각 스테이지의 지연을 줄입니다.
• 리타이밍(Retiming): 기존 플립플롭의 위치를 이동시켜 임계 경로를 균등하게 분배합니다.

슬랙 분석 (Setup & Hold Slack)

슬랙(Slack)은 타이밍 여유를 나타내는 지표입니다. 양수이면 타이밍 조건을 충족하고, 음수이면 타이밍 위반이 발생합니다.

셋업 슬랙: Setup Slack = T_clk − (t_cq + t_comb + t_su) — 반드시 0 이상이어야 합니다.

홀드 슬랙: Hold Slack = (t_cq + t_comb) − t_hold — 반드시 0 이상이어야 합니다.

정적 타이밍 분석 기초 (Static Timing Analysis)

정적 타이밍 분석(Static Timing Analysis, STA)은 테스트 벡터 없이 회로의 모든 타이밍 경로를 검사하는 기법입니다. STA의 핵심 개념은 도착 시간(Arrival Time), 요구 시간(Required Time), 슬랙(Slack = 요구 시간 − 도착 시간)입니다.

실제 반도체에서는 PVT 코너(Process, Voltage, Temperature)를 고려한 분석이 필수입니다:

• 셋업 분석(Worst-case Setup): Slow 공정 + Low 전압 + High 온도 — 가장 느린 조건에서 타이밍 충족 확인
• 홀드 분석(Worst-case Hold): Fast 공정 + High 전압 + Low 온도 — 가장 빠른 조건에서 타이밍 충족 확인

타이밍 다이어그램 읽기

타이밍 다이어그램은 디지털 신호의 시간에 따른 변화를 시각적으로 표현합니다. AXI4 읽기 채널을 예로 살펴보겠습니다. AXI 프로토콜은 밸리드-레디 핸드셰이크 방식을 사용하며, 전송은 VALID와 READY가 모두 클록 상승 에지에서 높을 때만 발생합니다.

STA 방법론 상세

정적 타이밍 분석(Static Timing Analysis, STA)은 시뮬레이션 없이 회로의 모든 타이밍 경로를 수학적으로 검증하는 방법론입니다. STA는 3가지 핵심 개념으로 구성됩니다:

도착 시간과 요구 시간

• 도착 시간(Arrival Time, AT): 클록 에지로부터 데이터가 목적지 플립플롭의 D 입력에 도달하는 시간입니다. 소스 FF의 Tcq + 조합 논리 지연의 합으로 계산합니다.
• 요구 시간(Required Time, RT): 목적지 플립플롭이 데이터를 올바르게 캡처하기 위해 데이터가 안정되어야 하는 최소 시간입니다. 셋업 분석에서는 RT = T_clk - T_setup이고, 홀드 분석에서는 RT = T_hold입니다.
• 슬랙(Slack): Slack = Required Time - Arrival Time. 양수이면 타이밍 조건을 충족하고, 음수이면 타이밍 위반이 발생합니다.

셋업/홀드 슬랙 계산 공식

셋업 슬랙 (Setup Slack):
  Slack_setup = (T_clk + T_skew) - (T_cq + T_comb + T_setup)
  T_clk  : 클록 주기
  T_skew : 클록 스큐 (목적지 클록 지연 - 소스 클록 지연)
  T_cq   : 소스 FF의 클록-투-출력 지연
  T_comb : 조합 논리 경로의 최대 지연
  T_setup: 목적지 FF의 셋업 시간

홀드 슬랙 (Hold Slack):
  Slack_hold = (T_cq + T_comb) - (T_hold + T_skew)
  T_hold : 목적지 FF의 홀드 시간

STA 지표

멀티코너/멀티모드 분석

실제 반도체 칩은 공정(Process), 전압(Voltage), 온도(Temperature) 변동에 의해 지연 특성이 크게 달라집니다. PVT 코너 분석은 이러한 변동을 고려하여 모든 조건에서 타이밍을 보장하는 설계 방법론입니다.

PVT 코너

코너별 분석 목적

• 최악 셋업 코너 (SS/Low V/High T): 트랜지스터가 가장 느리게 동작하는 조건입니다. 이 코너에서 셋업 슬랙이 양수이면 모든 조건에서 셋업 타이밍을 충족합니다.
• 최악 홀드 코너 (FF/High V/Low T): 트랜지스터가 가장 빠르게 동작하는 조건입니다. 데이터가 너무 빨리 도착하여 홀드 위반이 발생할 수 있습니다.
• 참고: 현대 미세 공정(28nm 이하)에서는 온도 반전 효과(Temperature Inversion)로 인해 저온에서 오히려 느려지는 경우가 있어, 전통적인 코너 선택이 항상 유효하지 않을 수 있습니다.

On-Chip Variation (OCV)

동일한 칩 내에서도 공정 편차가 존재합니다. OCV 분석은 데이터 경로와 클록 경로에 서로 다른 지연 스케일링 팩터(Derating Factor)를 적용하여 이를 모델링합니다:

• 셋업 분석: 데이터 경로에 최대 지연(late), 클록 경로에 최소 지연(early) 적용 — 가장 보수적인 셋업 조건
• 홀드 분석: 데이터 경로에 최소 지연(early), 클록 경로에 최대 지연(late) 적용 — 가장 보수적인 홀드 조건
• AOCV(Advanced OCV): 경로의 길이(로직 깊이)와 거리에 따라 차등적으로 디레이팅 팩터를 적용하여 OCV보다 현실적인 분석을 제공합니다

시그노프 (Signoff) 코너 세트

칩 제조 전 최종 타이밍 검증(Signoff)에 사용되는 코너 세트는 일반적으로 5~12개로 구성됩니다. 대표적인 시그노프 코너는 다음과 같습니다:

비동기 설계와 클록 도메인 교차 (Asynchronous Design & CDC)

현대 SoC에는 서로 다른 주파수와 위상의 클록 도메인(Clock Domain)이 수십 개 이상 존재합니다. 이 도메인 사이에서 신호를 안전하게 전달하는 것은 디지털 설계에서 가장 까다로운 문제 중 하나입니다.

핸드셰이크 프로토콜

4단계 핸드셰이크(4-Phase Handshake)는 복귀-영점 방식입니다:

1. 송신자가 REQ를 높임 → 데이터 유효
2. 수신자가 ACK를 높임 → 데이터 수신 완료
3. 송신자가 REQ를 낮춤 → 초기 상태 복귀 시작
4. 수신자가 ACK를 낮춤 → 초기 상태 복귀 완료

2단계 핸드셰이크(2-Phase Handshake)는 전이 신호 방식으로, 신호의 전이 자체가 이벤트를 나타냅니다. 초기 상태 복귀 단계가 없으므로 더 효율적이지만 구현이 복잡합니다.

클록 도메인 교차 분류 (CDC Taxonomy)

클록 도메인 교차(Clock Domain Crossing, CDC)는 한 클록 도메인의 신호를 다른 클록 도메인으로 안전하게 전달하는 것입니다. 신호 유형에 따라 적절한 동기화 기법이 다릅니다:

• 단일 비트 교차: 2단 플립플롭 동기화기(2-FF Synchronizer)
• 멀티 비트 교차: 그레이 코드 인코딩(카운터), MUX 리서큘레이션(데이터 버스)
• 펄스 교차: 토글 플립플롭 + 2-FF 동기화기 + 에지 검출기
• 버스/데이터 교차: 비동기 FIFO 또는 핸드셰이크 기반

CDC 검증과 흔한 실수

CDC 설계에서 가장 흔히 발생하는 실수입니다:

• 신호 재수렴: 같은 소스 도메인의 두 신호를 독립적으로 동기화하면, 대상 도메인에서 타이밍이 불일치합니다.
• 멀티 비트 개별 동기화: 바이너리 카운터를 그레이 코드 변환 없이 교차시키면 레이스 컨디션이 발생합니다. 예: 0111 → 1000 전이에서 4비트 모두 변경되어 임의의 값이 읽힙니다.
• 리셋 비동기 해제: "비동기 인가, 동기 해제(Async Assert, Sync Deassert)" 원칙을 따라야 합니다.

커널에서의 비동기 인터페이스

하드웨어의 CDC 개념은 커널의 여러 메커니즘에 대응됩니다:

• 메모리 배리어: mb(), rmb(), wmb(), smp_mb() — 소프트웨어 차원의 순서 보장
• readl()/writel(): MMIO 레지스터 접근 시 배리어 포함
• SPI/I2C 컨트롤러: CPU 클록 도메인과 주변장치 클록 도메인 사이의 브릿지
• synchronize_rcu(): 비동기 FIFO 배수와 유사 — 기존 읽기 완료까지 대기

/* 커널에서의 메모리 배리어 사용 — CDC 관점 */

/* 장치에 명령 시퀀스 전달 (쓰기 순서 보장) */
writel(cmd_addr, dev->base + REG_CMD_ADDR);
writel(cmd_data, dev->base + REG_CMD_DATA);
wmb();                                        /* 위 쓰기 완료 보장 */
writel(1, dev->base + REG_CMD_GO);            /* 실행 트리거 */

/* 공유 메모리 생산자-소비자 패턴 */
WRITE_ONCE(shared_buf->data, new_value);
smp_wmb();                                    /* 쓰기 배리어 */
WRITE_ONCE(shared_buf->flag, 1);              /* 완료 알림 */

/* DMA 완료 후 데이터 읽기 */
static irqreturn_t dma_irq_handler(int irq, void *dev_id)
{
    dma_rmb();                                /* DMA 읽기 배리어 */
    process_data(dev->dma_buf, dev->dma_len);
    return IRQ_HANDLED;
}

비동기 FIFO 설계 상세

비동기 FIFO(Asynchronous FIFO)는 서로 다른 클록 도메인 사이에서 데이터를 안전하게 전달하는 핵심 구성 요소입니다. 설계의 핵심은 쓰기/읽기 포인터를 그레이 코드(Gray Code)로 변환하여 CDC를 수행하는 것입니다.

그레이 코드 포인터

바이너리 카운터를 그레이 코드로 변환하면 연속된 값 사이에 정확히 1비트만 변경됩니다. 이 특성이 CDC에서 결정적으로 중요합니다:

• 바이너리 포인터의 문제: 0111 → 1000 전이에서 4비트 모두 동시에 변경되므로, CDC 중 일부 비트만 갱신된 중간값(예: 1111, 0000)이 읽힐 수 있습니다
• 그레이 코드의 해결: 1비트만 변경되므로, 동기화기가 새 값 또는 이전 값 중 하나만 읽게 됩니다. 중간의 잘못된 값이 나타나지 않습니다
• 변환 공식: gray = binary ^ (binary >> 1), 역변환은 XOR 누적으로 수행합니다

풀(Full)과 엠프티(Empty) 판정

풀과 엠프티 판정은 그레이 코드 포인터의 비교로 수행됩니다. FIFO 깊이가 2^N인 경우 (N+1)비트 포인터를 사용합니다(최상위 비트가 랩어라운드를 감지):

풀 판정의 구체적 조건: wptr_gray[N:N-1] == ~rptr_sync[N:N-1] 이고 wptr_gray[N-2:0] == rptr_sync[N-2:0]일 때 풀로 판정합니다.

보수적 판정

2단 동기화기의 지연(2 클록 사이클)으로 인해 풀/엠프티 플래그는 약간 보수적(Conservative)으로 동작합니다:

• 풀 판정: 읽기 포인터의 동기화 지연으로 실제보다 약간 일찍 풀로 판정될 수 있습니다. 이는 안전한 방향입니다(오버플로 방지).
• 엠프티 판정: 쓰기 포인터의 동기화 지연으로 실제보다 약간 일찍 엠프티로 판정될 수 있습니다. 이도 안전한 방향입니다(언더플로 방지).
• 성능 영향: 보수적 판정으로 인해 FIFO의 유효 깊이가 약간 줄어들지만, 정확성이 보장됩니다.

리셋 동기화

디지털 시스템의 리셋(Reset)은 모든 순차 소자를 알려진 초기 상태로 설정하는 중요한 메커니즘입니다. 리셋의 인가(Assert)와 해제(Deassert) 과정에서 타이밍 문제가 발생할 수 있습니다.

비동기 어서트 / 동기 디어서트

리셋 설계의 황금률은 "비동기 인가, 동기 해제(Asynchronous Assert, Synchronous Deassert)"입니다:

• 비동기 인가: 리셋 신호가 활성화되면 클록 에지를 기다리지 않고 즉시 플립플롭을 리셋합니다. 이는 클록이 아직 안정되지 않은 시스템 시작 시에도 확실한 리셋을 보장합니다.
• 동기 해제: 리셋 해제는 클록 상승 에지에 동기화되어 수행됩니다. 비동기 해제는 플립플롭의 리커버리 시간(Recovery Time)/제거 시간(Removal Time) 위반을 초래하여 메타안정성을 유발할 수 있습니다.

리셋 동기화기 회로

리셋 동기화기는 2단 플립플롭 체인으로 구성됩니다. 입력은 비동기 리셋 신호이고, 출력은 동기화된 리셋 해제 신호입니다:

// 리셋 동기화기 — 비동기 어서트, 동기 디어서트
module reset_sync (
    input  wire clk,
    input  wire async_rst_n,    // 외부 비동기 리셋 (액티브 로우)
    output wire sync_rst_n      // 동기화된 리셋 출력
);
reg [1:0] rst_pipe;

always @(posedge clk or negedge async_rst_n) begin
    if (!async_rst_n)
        rst_pipe <= 2'b00;           // 즉시 리셋 (비동기)
    else
        rst_pipe <= {rst_pipe[0], 1'b1};  // 동기 해제 (2단계)
end

assign sync_rst_n = rst_pipe[1];
endmodule

리셋 트리

대규모 설계에서는 리셋 신호가 수천 개의 플립플롭에 팬아웃(Fan-out)됩니다. 리셋 트리(Reset Tree)는 이 팬아웃을 제어하기 위한 버퍼 네트워크입니다:

• 리셋 버퍼 삽입: 클록 트리와 유사하게, 리셋 신호의 전파 지연과 팬아웃을 관리하기 위해 버퍼 체인을 삽입합니다
• 리셋 스큐: 리셋 해제 타이밍이 모든 플립플롭에서 동일한 클록 에지에 발생하도록 스큐를 최소화해야 합니다
• EDA 도구 지원: 합성 도구와 배치배선(P&R) 도구가 리셋 트리를 자동으로 최적화합니다

멀티 클록 도메인 리셋

여러 클록 도메인이 존재하는 SoC에서는 각 도메인마다 독립적인 리셋 동기화기가 필요합니다:

• 각 클록 도메인에 별도의 리셋 동기화기를 배치하여, 해당 도메인의 클록에 맞춰 리셋을 해제합니다
• 도메인 간 리셋 해제 순서가 중요한 경우, 의존 관계에 따라 순차적으로 리셋을 해제합니다(예: 메모리 컨트롤러 → 버스 → 주변장치 순서)
• 전원 관리(Power Management)와 연계하여 특정 도메인만 리셋하는 부분 리셋(Partial Reset) 기능이 필요할 수 있습니다

전력 최적화 (Power Optimization)

현대 프로세서에서 전력 소비는 성능만큼 중요한 설계 지표입니다. 이 절에서는 동적 전력과 정적 전력의 물리적 원리부터 커널의 전력 관리 인터페이스까지 살펴봅니다.

동적 전력 (Dynamic Power)

동적 전력은 회로가 스위칭할 때 소비되는 전력입니다:

P_dynamic = α · C_L · V_DD² · f_clk

α     : 활동 계수 (Activity Factor) — 사이클당 스위칭 게이트 비율 (0.1~0.3)
C_L   : 부하 정전용량 — 게이트 팬아웃, 배선 길이에 의해 결정
V_DD  : 공급 전압 — 제곱 관계이므로 작은 전압 감소가 큰 전력 절감
f_clk : 클록 주파수

동적 전력은 스위칭 전력(출력 노드 정전용량 충·방전)과 단락 전류 전력(PMOS/NMOS 동시 도통 구간)으로 구성됩니다.

정적 전력과 누설 전류 (Leakage)

정적 전력은 회로가 스위칭하지 않을 때도 소비되는 전력입니다. 주요 메커니즘:

• 서브쓰레숄드 누설: 게이트 전압이 Vth 이하일 때 채널을 통해 흐르는 전류. Vth와 지수적 관계
• 게이트 산화막 누설: 얇은 산화막을 통한 양자 터널링. High-k 유전체로 완화
• 접합 누설: 역바이어스 PN 접합 전류

온도가 약 10°C 상승할 때마다 누설 전류가 약 2배 증가합니다.

클록 게이팅 (Clock Gating)

클록 게이팅은 동적 전력을 줄이는 가장 효과적인 기법입니다. 기본 AND 게이트 방식은 글리치 문제가 있으므로, 래치 기반 ICG(Integrated Clock Gating) 셀을 사용합니다:

1. enable 신호를 CLK 하강 에지에서 래치로 캡처합니다.
2. 래치 출력과 CLK을 AND 게이트로 결합합니다.
3. CLK High 구간 동안 enable 변화가 차단되어 글리치가 발생하지 않습니다.

/* 커널 드라이버에서의 클록 게이팅 제어 */
struct clk *spi_clk = devm_clk_get(&pdev->dev, "spi_clk");
clk_prepare_enable(spi_clk);     /* 클록 게이트 개방 */
/* ... SPI 전송 수행 ... */
clk_disable_unprepare(spi_clk);  /* 클록 게이트 차단 → 동적 전력 = 0 */

파워 게이팅 (Power Gating)

파워 게이팅은 사용하지 않는 블록의 전원 자체를 차단하여 누설 전류를 제거합니다. 두 가지 구현 방식:

• 헤더 스위치: PMOS 슬립(Sleep) 트랜지스터를 VDD와 가상 VDD 사이에 배치
• 푸터 스위치: NMOS 슬립 트랜지스터를 가상 VSS와 VSS 사이에 배치

보조 회로 요소:

• 보존 레지스터: 전원 차단 전 상태를 상시 전원 래치에 저장
• 격리(Isolation) 셀(Isolation Cell): 전원이 꺼진 블록의 출력을 안전한 값으로 고정

파워 업 시퀀스: 전원 인가 → 격리 해제 → 상태 복원 → 클록 인가. 파워 다운은 반대 순서입니다.

/* 커널 런타임 PM — 파워 게이팅 매핑 */
pm_runtime_get_sync(&pdev->dev);           /* 파워 게이트 개방 */
/* ... 디바이스 사용 ... */
pm_runtime_mark_last_busy(&pdev->dev);
pm_runtime_put_autosuspend(&pdev->dev);   /* 자동 서스펜드 → 파워 게이트 차단 */

멀티 Vt 설계 (Multi-Threshold Voltage)

멀티 Vt 설계는 같은 칩 안에서 서로 다른 문턱 전압의 트랜지스터를 혼합합니다:

CPU 비닝(Binning)은 멀티 Vt의 실제 적용 결과입니다. 공정 편차에 의해 칩마다 Vt 분포가 달라져, 동일 설계에서 다른 등급(i9/i7/i5)으로 분류됩니다.

커널 전력 관리 매핑

하드웨어 전력 최적화 기법과 리눅스 커널 인터페이스의 대응 관계입니다:

• DVFS → cpufreq: OPP 테이블로 검증된 전압-주파수 조합 관리
• 클록 게이팅 → clk_disable()/clk_enable(): 공통 클록 프레임워크
• 파워 게이팅 → pm_runtime_*: 런타임 PM으로 전원 도메인 제어
• CPU 유휴 → cpuidle: C-state 관리 (C0=활성, C1=클록게이팅, C6=파워게이팅)
• 에너지 인식 스케줄링(EAS): big.LITTLE에서 전력 효율 기반 CPU 선택

/* 커널 전력 관리 종합 예시 */
static int my_device_runtime_resume(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);
    clk_prepare_enable(mydev->clk);       /* 클록 게이팅 해제 */
    clk_set_rate(mydev->clk, 200000000);  /* 200MHz 설정 */
    return 0;
}

static int my_device_runtime_suspend(struct device *dev)
{
    struct my_device *mydev = dev_get_drvdata(dev);
    clk_disable_unprepare(mydev->clk);    /* 클록 게이팅 */
    return 0;                              /* genpd가 전원 도메인 차단 */
}

static const struct dev_pm_ops my_pm_ops = {
    SET_RUNTIME_PM_OPS(my_device_runtime_suspend,
                       my_device_runtime_resume, NULL)
};

테스트와 검증 (Testing & Verification)

반도체 제조 과정에서 발생하는 결함을 검출하고, 설계 의도대로 동작하는지 확인하는 과정은 디지털 회로 개발의 핵심입니다.

결함 모델 (Fault Models)

결함 모델은 물리적 결함을 추상화한 것으로, 테스트 패턴 생성의 기반입니다.

테스트 패턴 자동 생성 (ATPG)

ATPG(Automatic Test Pattern Generation)는 결함을 검출할 입력 패턴을 자동 생성하는 기술입니다. D-알고리즘의 3단계:

1. 결함 활성화: 결함 지점에 결함 유무에 따라 다른 값이 나타나도록 입력 설정
2. 결함 전파: 결함 효과를 관찰 가능한 출력까지 전파
3. 정당화: 전파 경로상의 다른 입력들을 필요한 값으로 설정

테스트 압축 기술은 LFSR 기반 디컴프레서로 소수의 시드에서 실제 패턴을 생성하여, 테스트 시간을 10~100배 줄입니다.

테스트 용이 설계 (Design for Testability)

DFT의 핵심 개념은 제어 가능성(Controllability)과 관찰 가능성(Observability)입니다. 구조적 DFT(스캔 체인 삽입)가 현대 반도체의 표준입니다.

스캔 체인 (Scan Chain)

스캔 플립플롭은 일반 D 플립플롭에 MUX를 추가한 구조입니다. SE(Scan Enable)=0이면 기능적 입력, SE=1이면 스캔 입력을 선택합니다.

스캔 테스트 절차: 시프트 인(패턴 로드) → 캡처(기능적 클록 1사이클) → 시프트 아웃(응답 추출) → 비교(기대값 대조)

내장 자체 테스트 (BIST)

BIST는 테스트 하드웨어를 칩 내부에 내장하는 기법입니다. 로직 BIST는 LFSR(패턴 생성기) → CUT(피테스트 회로) → MISR(시그니처 분석기) 구조를 사용합니다.

메모리 BIST(MBIST)는 SRAM 어레이 전용 테스트로, March C- 알고리즘(↑w0, ↑r0w1, ↑r1w0, ↓r0w1, ↓r1w0, ↑r0)을 자동 실행합니다.

TAP 컨트롤러 FSM

TAP(Test Access Port)는 IEEE 1149.1(JTAG) 표준의 테스트 인터페이스입니다. 5개 신호(TCK, TMS, TDI, TDO, TRST)와 16개 상태의 FSM으로 구성됩니다.

ATPG와 DFT 기법

DFT(Design for Testability)는 테스트 용이성을 설계 단계부터 고려하는 접근법으로, 양산 칩의 품질을 보장하기 위해 필수적입니다.

DFT 핵심 개념

• 제어 가능성(Controllability): 회로 내부 노드를 원하는 논리값(0 또는 1)으로 설정할 수 있는 정도입니다. 제어 가능성이 낮은 노드는 결함을 활성화하기 어렵습니다.
• 관찰 가능성(Observability): 내부 노드의 값을 외부 출력에서 관찰할 수 있는 정도입니다. 관찰 가능성이 낮은 노드는 결함 효과를 검출하기 어렵습니다.
• 테스트 포인트(Test Point): 제어/관찰 가능성이 낮은 지점에 삽입하는 추가 논리입니다. 제어 포인트(MUX + 스캔 셀)와 관찰 포인트(OR/AND + 스캔 셀)가 있습니다.

스캔 체인 삽입 흐름

1. 스캔 FF 교체: 일반 D 플립플롭을 스캔 플립플롭(D-FF + MUX)으로 교체합니다. SE(Scan Enable) 신호로 기능 모드와 스캔 모드를 전환합니다.
2. 체인 연결(Chain Stitching): 스캔 FF들을 직렬로 연결하여 하나 이상의 스캔 체인을 구성합니다. 체인 수는 테스트 시간과 I/O 핀 수의 트레이드오프로 결정합니다.
3. 테스트 포인트 삽입: DFT 분석 결과 제어/관찰 가능성이 부족한 지점에 테스트 포인트를 자동 삽입합니다.
4. ATPG 실행: 결함 모델(고착, 전이, 브리징)에 대해 테스트 패턴을 자동 생성합니다.

ATPG 알고리즘

결함 커버리지

결함 커버리지(Fault Coverage) = 검출된 결함 수 / 전체 결함 수 × 100%. 양산 품질 목표에 따라 요구 수준이 달라집니다:

• 95~97%: 일반 소비자 전자제품
• 99%+: 자동차(ISO 26262), 의료기기, 산업용
• 99.5%+: 항공/우주, 안전 핵심(Safety-Critical) 시스템

검출 불가능한 결함(Redundant Faults)을 제외하면 실효 커버리지(Test Effectiveness)로 평가합니다.

JTAG 활용 확장

JTAG(IEEE 1149.1)은 경계 스캔 테스트를 넘어 다양한 용도로 확장되었습니다.

TAP 컨트롤러 16상태 FSM

TAP 컨트롤러는 TMS(Test Mode Select) 신호에 의해 구동되는 16개 상태의 FSM입니다. 핵심 경로는 DR(Data Register) 경로와 IR(Instruction Register) 경로 두 가지입니다:

• Test-Logic-Reset → Run-Test/Idle: TMS=0으로 유휴 상태(Idle State) 진입. 전원 인가 시 5사이클 동안 TMS=1을 유지하면 어떤 상태에서든 TLR로 복귀합니다.
• DR 경로: Select-DR → Capture-DR → Shift-DR → Exit1-DR → (Pause-DR → Exit2-DR →) Update-DR. 데이터 레지스터를 시프트하고 업데이트합니다.
• IR 경로: Select-IR → Capture-IR → Shift-IR → Exit1-IR → (Pause-IR → Exit2-IR →) Update-IR. 명령 레지스터를 시프트하고 업데이트합니다.
• Pause 상태: 긴 시프트 연산 중 일시 정지가 필요할 때 사용합니다. 디버거가 데이터를 준비하는 동안 체인을 유지합니다.

BSDL (Boundary Scan Description Language)

BSDL 파일은 디바이스의 경계 스캔 구조를 기술하는 VHDL 서브셋 파일입니다. JTAG 테스트 도구가 디바이스를 올바르게 제어하기 위해 필수적입니다:

• entity 선언: 디바이스 핀 이름, 패키지 타입, 핀 매핑
• BSR 속성: 각 핀의 경계 스캔 셀 유형(input, output, bidir, internal)
• 명령어 레지스터: 지원하는 JTAG 명령어와 opcode (BYPASS, EXTEST, IDCODE 등)
• IDCODE: 32비트 디바이스 식별자 (제조사 코드, 부품 번호, 버전)

멀티칩 JTAG 데이지 체인

하나의 JTAG 포트로 보드상의 여러 디바이스를 TDO→TDI 직렬 연결합니다:

• 각 칩의 BSR이 하나의 긴 시프트 레지스터를 구성합니다
• BYPASS 명령: 관심 없는 디바이스를 1비트 바이패스 레지스터로 단축하여 시프트 시간을 줄입니다
• 체인의 총 IR 길이 = 각 디바이스 IR 길이의 합. 특정 디바이스에 명령을 전달하려면 다른 디바이스에는 BYPASS를 로드합니다
• 자동 감지: IDCODE를 순차적으로 시프트아웃하여 체인 내 디바이스를 자동으로 식별할 수 있습니다

JTAG를 이용한 인서킷 프로그래밍 (ISP)

JTAG 인터페이스를 통해 타겟 보드에 장착된 상태로 디바이스를 프로그래밍하는 기법입니다:

• FPGA 비트스트림 로드: JTAG를 통해 SRAM 기반 FPGA에 비트스트림을 직접 로드하거나, 구성 플래시에 기록합니다
• SPI 플래시 프로그래밍: JTAG → FPGA 바운더리 스캔 → SPI 핀 제어 경로로 외부 플래시를 프로그래밍합니다
• MCU 플래시 프로그래밍: ARM의 SWD(Serial Wire Debug)는 JTAG의 축소판으로, 2핀(SWDIO, SWCLK)만으로 디버깅과 플래시 프로그래밍이 가능합니다

HDL 기초 (Hardware Description Language Basics)

하드웨어 기술 언어(Hardware Description Language, HDL)는 디지털 회로의 구조와 동작을 텍스트로 기술하는 언어입니다. 커널 개발자가 HDL을 이해하면 하드웨어 레지스터 맵의 유래와 드라이버 레지스터 접근 패턴의 근본적인 이유를 파악할 수 있습니다.

Verilog 기본 문법

Verilog의 module 선언, wire/reg 타입, always 블록, assign 문 등의 문법 상세는 별도 문서를 참고하세요.

시뮬레이션과 합성

시뮬레이션(Simulation)은 Verilog를 소프트웨어로 실행하여 동작을 검증하고, 합성(Synthesis)은 RTL을 게이트 레벨 넷리스트로 변환합니다.

주요 합성 최적화: 자원 공유(동시에 사용되지 않는 연산기 공유), 연산자 밸런싱(a+b+c+d → (a+b)+(c+d)로 2단계), 레지스터 리타이밍(파이프라인 레지스터 위치 조정).

커널 드라이버 관점에서의 HDL 이해

RTL 레지스터 정의가 드라이버의 레지스터 맵으로 매핑되는 과정을 살펴봅니다.

간소화된 UART 송신기 Verilog

module uart_tx_regs (
    input  wire        clk, rst_n,
    input  wire [3:0]  addr,
    input  wire        wr_en,
    input  wire [31:0] wr_data,
    output reg  [31:0] rd_data
);
reg [7:0]  tx_data;    // 오프셋 0x00: 송신 데이터
reg        tx_valid;   // 오프셋 0x04 [0]: 송신 시작
reg        tx_busy;    // 오프셋 0x08 [0]: 송신 중 (읽기 전용)
reg [15:0] baud_div;   // 오프셋 0x0C: 보레이트 분주 값

always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        tx_data <= 8'h00; tx_valid <= 1'b0; baud_div <= 16'd868;
    end else if (wr_en) begin
        case (addr)
            4'h0: tx_data  <= wr_data[7:0];
            4'h1: tx_valid <= wr_data[0];
            4'h3: baud_div <= wr_data[15:0];
        endcase
    end
end
endmodule

대응하는 커널 드라이버 레지스터 접근

/* RTL의 reg 정의가 드라이버 오프셋으로 매핑됩니다 */
#define UART_TX_DATA    0x00    /* tx_data [7:0]  */
#define UART_TX_CTRL    0x04    /* tx_valid [0]   */
#define UART_TX_STATUS  0x08    /* tx_busy [0] — 읽기 전용 */
#define UART_BAUD_DIV   0x0C    /* baud_div [15:0] */

static int uart_tx_char(struct uart_port *port, unsigned char ch)
{
    void __iomem *base = port->membase;

    /* tx_busy는 읽기 전용 — 송신기 사용 중이면 대기 */
    while (readl(base + UART_TX_STATUS) & 0x1)
        cpu_relax();

    writel(ch, base + UART_TX_DATA);     /* tx_data 설정 */
    writel(1, base + UART_TX_CTRL);       /* tx_valid → 송신 시작 */
    return 0;
}

디바이스 트리의 reg 속성은 RTL 주소 디코더의 베이스 주소와 크기에 대응합니다. 커널 드라이버의 readl(base + offset) / writel(val, base + offset)은 RTL의 case (addr) 구조를 직접 반영합니다.

커널과의 관계 (Relation to Kernel)

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

레지스터 파일과 컨텍스트 스위칭(Context Switching)

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 정책에 영향을 줍니다. 메모리 컨트롤러의 디코더가 물리 주소(Physical Address)를 행/뱅크/열로 분해하는 방식은 메모리 접근 패턴의 성능에 직접적인 영향을 미칩니다.

커널의 struct zone과 struct pglist_data는 물리 메모리(Physical Memory)의 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)합니다. 이는 파이프라인의 각 스테이지가 독립적인 조합/순차 논리회로로 구현되기 때문에 가능합니다. 그러나 장치 레지스터 접근에서는 순서가 중요합니다.

/* 메모리 배리어 — 하드웨어 순서 보장 명령 */
/* 장치 레지스터 쓰기 순서가 중요한 경우 */
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 파이프라인은 명령 실행을 여러 단계(Fetch → Decode → Execute → Memory → Writeback)로 분할한 구조입니다. 각 단계가 독립적인 조합/순차 논리회로로 구현되며, 단계 사이에 파이프라인 레지스터가 있어 각 단계가 동시에 서로 다른 명령을 처리합니다.

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

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

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

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

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

Spectre 대응: 간접 분기 예측 방어

retpoline은 간접 점프를 RET 명령으로 대체하는 기법입니다. 분기 예측기(BTB)가 아닌 RSB(Return Stack Buffer)를 사용하며, RSB는 CALL/RET 쌍에만 반응하므로 공격자가 조작할 수 없습니다.

KPTI (Kernel Page Table Isolation)는 Meltdown 대응 기법으로, 커널/사용자 페이지 테이블(Page Table)을 분리하여 투기적 실행으로도 커널 메모리에 접근할 수 없도록 합니다.

취약점 상태 확인:

$ 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 Manager/Bridge/Region 프레임워크, 부분 재구성 등 심화 내용은 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 디버거는 이 레지스터를 직접 제어할 수 있어, 커널이 완전히 멈춘 상태(커널 패닉(Kernel Panic), 부트 초기)에서도 디버깅이 가능합니다
• JTAG 디버거(OpenOCD, J-Link) — 임베디드 리눅스 개발에서 부트로더부터 커널까지 전체 부팅 과정(Boot Process)을 단계별로 추적할 수 있습니다. 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는 소프트웨어에서 접근 */

FPGA 내부 라우팅 아키텍처

FPGA의 성능과 라우팅 가능성은 내부 인터커넥트 아키텍처에 의해 크게 좌우됩니다. CLB 사이의 신호 전달은 프로그래밍 가능한 스위치와 배선 채널을 통해 이루어집니다.

스위치 박스 (Switch Box)

스위치 박스는 CLB 사이의 교차점에 위치하며, 수평과 수직 라우팅 채널을 연결하는 프로그래밍 가능 스위치 매트릭스입니다:

• Wilton 토폴로지: 현대 FPGA에서 가장 보편적인 스위치 박스 구조입니다. 각 방향의 와이어가 다른 방향의 특정 와이어에 연결되어 라우팅 다양성을 극대화합니다.
• 패스 트랜지스터(Pass Transistor) 또는 MUX로 스위치를 구현하며, 구성 SRAM 비트가 연결 여부를 결정합니다.
• 버퍼링: 긴 경로에서는 신호 무결성을 위해 스위치 사이에 드라이버 버퍼를 삽입합니다.

연결 박스 (Connection Box)

연결 박스는 CLB의 입출력 핀과 라우팅 채널을 연결합니다:

• 입력 연결 박스: 라우팅 채널의 와이어 중 일부를 CLB 입력 핀으로 연결할 수 있습니다. 연결 유연성(Flexibility) Fc = 연결 가능한 와이어 수 / 전체 와이어 수.
• 출력 연결 박스: CLB 출력을 라우팅 채널의 와이어에 연결합니다.
• Fc 값의 트레이드오프: Fc가 높을수록 라우팅 성공률이 높아지지만, 스위치 수와 기생 캐패시턴스가 증가하여 면적과 지연에 불리합니다.

라우팅 채널과 세그먼트

라우팅 채널은 수평과 수직 방향의 배선 자원으로 구성됩니다:

• 짧은 세그먼트(Short Segment): 인접 CLB 간 연결에 사용됩니다. 지연이 짧지만, 먼 CLB까지 도달하려면 여러 스위치를 거쳐야 합니다.
• 긴 세그먼트(Long Segment): 여러 CLB를 건너뛰는 고속 배선입니다. 칩 전체 클록 분배나 긴 거리 신호 전달에 사용됩니다.
• 채널 폭(Channel Width, W): 한 채널 내의 와이어 수. W가 클수록 라우팅 용량이 커지지만, 칩 면적이 증가합니다.

라우팅 혼잡 (Routing Congestion)

특정 영역에서 배선 자원 수요가 공급을 초과하면 라우팅 혼잡이 발생합니다:

• 증상: 배치배선(P&R) 도구가 우회 경로를 사용하여 와이어 지연이 증가하고, 타이밍 조건을 만족하지 못할 수 있습니다
• 원인: 높은 팬아웃 넷, 밀집된 로직 배치, 부족한 라우팅 자원
• 해결: 로직 밀도 감소(FPGA 활용률을 70~80% 이하로 유지), 파이프라인 삽입, 배치 제약(Floorplanning)으로 혼잡 영역 분산

안티퓨즈/플래시 기반 FPGA

FPGA의 구성 메모리 기술에 따라 부팅 특성, 보안성, 전력 소비 등이 크게 달라집니다. 현재 3가지 주요 기술이 사용됩니다.

SRAM 기반 FPGA

현재 가장 보편적인 FPGA 기술입니다. Xilinx(AMD)의 Virtex/Artix/Kintex 시리즈와 Intel(Altera)의 Stratix/Cyclone 시리즈가 대표적입니다:

• 전원 인가 시 외부 메모리(SPI 플래시 등)에서 비트스트림을 로드해야 합니다
• 무제한 재프로그래밍이 가능하여 개발과 현장 업데이트에 적합합니다
• 최신 공정 노드(7nm, 5nm)를 사용할 수 있어 최고 집적도와 성능을 제공합니다
• SRAM 누설 전류로 인해 대기 전력이 상대적으로 높습니다

플래시 기반 FPGA

비휘발성 구성 메모리를 사용하여 전원 인가 즉시 동작합니다. Microchip(구 Microsemi)의 PolarFire, SmartFusion2가 대표적입니다:

• 즉시 부팅(Instant-On): 외부 비트스트림 로드가 불필요하여 밀리초 이내에 동작 시작합니다
• 비트스트림이 칩 내부에 저장되어 외부 공격에 대한 보안이 우수합니다
• SRAM 대비 낮은 대기 전력으로 배터리 구동 장치에 적합합니다
• 프로그래밍 횟수에 제한이 있지만(수만~수십만 회), 대부분의 응용에 충분합니다

안티퓨즈 기반 FPGA

OTP(One-Time Programmable) 방식으로, 한 번 프로그래밍하면 변경할 수 없습니다. Microchip의 RTAX(우주용) 시리즈가 대표적입니다:

• 프로그래밍 시 절연체에 영구적 도전 경로를 형성하여 연결합니다
• 방사선 내성(Radiation Hardness)이 우수하여 우주/항공 응용에 사용됩니다 — SRAM 기반 FPGA는 방사선에 의한 SEU(Single Event Upset)로 구성이 변경될 수 있습니다
• 역공학이 사실상 불가능하여 보안에 유리합니다
• 현장 업데이트가 불가능하고, 디버깅 시 매번 새 칩을 사용해야 하는 단점이 있습니다

기술별 비교

주요 회로 예시 — 단계별 회로 풀이

아래 예시는 디지털 설계에서 가장 자주 등장하는 회로를 게이트 수준(Gate-Level)으로 풀어 봅니다. 회로도(Schematic), 진리표(Truth Table) 또는 파형(Waveform), 그리고 신호가 어떻게 한 단계씩 전파되는지 따라가는 풀이를 함께 제공합니다. 여기서 다루는 회로는 조합 논리와 순차 논리 본문에서는 상위 추상화로만 등장하지만, 본 절에서는 결선과 신호의 의미를 직접 손으로 따라갈 수 있도록 단계 풀이를 제공합니다.

예시 1: 반가산기 (Half Adder) — XOR 1개 + AND 1개

반가산기(Half Adder)는 두 1비트 입력 A, B를 더해 합(Sum)과 올림(Cout)을 만드는 가장 작은 산술 회로입니다. 이름이 "반(half)"인 이유는 아래 자리에서 올라오는 캐리(Carry-In)를 처리하지 못하기 때문이며, 4비트 이상의 가산기를 만들 때는 LSB(최하위 비트, Least Significant Bit) 한 자리에서만 사용하고 나머지 자리는 전가산기를 사용합니다.

핵심 관찰: A와 B를 한 자리 이진수로 더하면 결과는 0, 1, 10(2)이 가능합니다. 즉 합 비트는 두 값이 다를 때 1(=A⊕B), 올림 비트는 두 값이 모두 1일 때 1(=A·B)입니다. 그래서 반가산기는 정확히 XOR 1개 + AND 1개로 구현됩니다.

단계별 신호 풀이 (입력 A=1, B=1을 가정하고 한 단계씩 따라가기):

1. 입력 단계: A 핀에 1, B 핀에 1이 인가됩니다. A는 회로도의 위쪽 수평선을 따라 (220,70) 지점에 도달하며, 거기서 두 갈래로 나뉩니다 — 한 갈래는 그대로 오른쪽으로 진행하여 XOR의 위 입력에, 다른 갈래는 아래로 꺾여 AND의 위 입력에 들어갑니다. B도 동일한 방식으로 두 갈래로 나뉘어 XOR의 아래 입력과 AND의 아래 입력에 도달합니다. 회로도의 동그라미 표식(●)은 두 선이 전기적으로 연결되어 있다는 표시입니다.
2. XOR 게이트 평가: XOR의 두 입력(A=1, B=1)이 같으므로 출력은 0입니다. XOR은 "두 입력이 다를 때만 1"을 출력하는 게이트로, 한 자리 덧셈에서 캐리를 제외한 합 비트와 정확히 일치합니다.
3. AND 게이트 평가: AND의 두 입력(A=1, B=1)이 모두 1이므로 출력은 1입니다. AND는 "두 입력이 모두 1일 때만 1"을 출력하는 게이트로, 두 1비트의 곱이 곧 캐리이기 때문에 올림 비트와 정확히 일치합니다.
4. 출력 정리: Sum = 0, Cout = 1. 두 비트를 (Cout, Sum) 순서로 읽으면 10₂ = 2₁₀. 즉 1 + 1 = 2가 정확히 표현되었습니다.
5. 다른 입력 조합: A=0, B=1이면 XOR 출력은 1(서로 다름), AND 출력은 0(둘 다 1이 아님)이 되어 Sum=1, Cout=0 — 즉 0+1 = 01₂. A=B=0이면 둘 다 0이 되어 0+0 = 00₂.

이 회로의 한계와 확장: 반가산기는 캐리-인(Cin, 아래 자리에서 올라온 올림)을 받지 못하므로 멀티비트 가산기의 LSB 한 자리에서만 단독 사용됩니다. 두 자리 이상이 되면 각 자리에 전가산기(Cin, A, B 3입력)가 필요하며, 4비트 가산기는 보통 LSB에 반가산기 1개 + 나머지 3자리에 전가산기 3개로 구성하거나, 모든 자리에 전가산기를 두고 LSB의 Cin만 0으로 묶어 사용합니다.

커널/실무 연결: 반가산기는 그 자체로는 잘 노출되지 않지만 모든 ALU(Arithmetic Logic Unit) 가산기 회로의 가장 작은 부품입니다. C 언어의 a + b가 한 비트 폭에서 어떻게 풀리는지 묻는다면, 정확히 이 회로의 진리표와 일치합니다. 또한 같은 회로를 1비트짜리 더하기/곱하기 관점으로 보면 GF(2) 산술과 일치하여, CRC(Cyclic Redundancy Check)와 같은 비트 단위 다항식 연산의 기본 단위가 됩니다.

예시 2: 2:1 멀티플렉서 — 게이트로 직접 풀어보기

2:1 멀티플렉서(MUX)는 선택 신호 S에 따라 두 입력 D0, D1 중 하나를 출력 Y로 보내는 회로입니다. 이미 본문 멀티플렉서 절에서 4:1 MUX의 블록 다이어그램을 보았는데, 여기서는 가장 작은 2:1 MUX를 NOT 1개 + AND 2개 + OR 1개로 직접 풀어 봅니다.

핵심 관찰: S=0이면 Y=D0, S=1이면 Y=D1이어야 합니다. 이를 부울 식으로 쓰면:

Y = D0 · S̅ + D1 · S

즉, "S가 0일 때만 D0을 통과시키는 항"과 "S가 1일 때만 D1을 통과시키는 항"을 OR로 합친 형태입니다. 이 식 그대로 게이트로 옮기면 회로가 됩니다.

단계별 신호 풀이 (S=0, D0=1, D1=0인 경우):

1. S 분기: S=0이 회로 좌하단에서 들어와 (160, 300) 지점에서 두 갈래로 분기됩니다. 하나는 위쪽으로 올라가 NOT 게이트의 입력으로, 다른 하나는 오른쪽으로 가서 AND2의 아래 입력으로 들어갑니다.
2. NOT 게이트 평가: S=0 → S̅=1. 이 결과가 AND1의 아래 입력으로 들어갑니다. NOT 게이트의 작은 동그라미(bubble)는 신호가 반전됨을 의미합니다.
3. AND1 평가 (위쪽 가지): AND1의 두 입력은 D0=1과 S̅=1입니다. 둘 다 1이므로 출력은 1이 됩니다. 의미적으로 "S=0이고 D0이 1이면 D0이 통과되어야 한다"가 성립합니다.
4. AND2 평가 (아래쪽 가지): AND2의 두 입력은 D1=0과 S=0입니다. 어느 하나라도 0이면 결과는 0이므로 출력은 0입니다. "S=0이면 D1은 차단되어야 한다"가 자연스럽게 강제됩니다.
5. OR 게이트 평가: OR의 두 입력은 AND1=1, AND2=0입니다. 어느 하나라도 1이면 출력은 1이므로 Y=1입니다.
6. 핵심 통찰: 두 AND 게이트는 "조건부 통과 게이트(Conditional Pass)" 역할을 하고, OR는 "둘 중 하나만 활성"인 결과를 모아주는 합류 지점(Junction)입니다. S와 S̅가 서로 보수이므로 어느 시점에도 두 AND 중 정확히 하나만 활성화 가능 신호를 가집니다.

n:1로 확장: 같은 패턴을 4:1 MUX로 확장하면 NOT 2개(S0̅, S1̅) + AND 4개(각각 D0·S1̅·S0̅ 등) + OR 1개(4입력)로 4입력 본문 4:1 MUX 블록 다이어그램의 식과 정확히 일치합니다. 이 구조 때문에 일반적으로 n:1 MUX는 게이트 수가 n에 비례해 늘어나며, FPGA에서는 LUT(Lookup Table) 1개로 4:1까지를 한 번에 표현할 수 있어 게이트 수가 보이지 않습니다.

커널/실무 연결: MUX는 C 언어의 삼항 연산자 S ? D1 : D0 또는 switch-case의 하드웨어 등가물입니다. 또 CPU에서 분기 예측 결과에 따라 두 후보 명령 중 하나를 선택하는 회로, ALU 출력 단에서 add/sub/and/or 결과 중 하나를 선택하는 회로, DDR 데이터 버스의 양방향 전환(read/write 데이터 경로 선택) 모두 다입력 MUX입니다.

예시 3: NAND 기반 SR 래치 (Active-Low S, R)

본문 SR 래치의 내부 구조에서는 NOR 2개로 만든 SR 래치를 보았습니다. 실제로 SRAM 셀이나 표준 셀 라이브러리에서 더 자주 보이는 형태는 NAND 기반 SR 래치입니다. NOR 버전과 달리 입력이 Active-Low(0이 활성)이고, 휴지(idle) 상태에서 입력을 모두 1로 두면 상태가 유지된다는 차이가 있습니다.

구조: 두 NAND 게이트의 출력을 서로의 입력으로 교차 결합(Cross-coupled)하고, 외부 입력으로 각각 S̅(Set, active-low)과 R̅(Reset, active-low)을 받습니다. 출력은 Q와 Q̅(보수, complement)입니다.

NAND 래치의 입출력 규약: S̅와 R̅는 모두 Active-Low이므로 평소(idle) 상태에서는 둘 다 1을 유지합니다. 1을 유지하는 동안에는 NAND의 다른 입력(피드백)이 출력을 결정하므로, 한 번 결정된 Q와 Q̅는 그대로 보존됩니다. 어느 한쪽 입력에 잠시 0이 인가되면(펄스) 그 변에 해당하는 동작(Set 또는 Reset)이 실행되고, 다시 1로 돌아오면 그 결과가 자기 유지(Self-holding)됩니다.

단계별 신호 풀이 (위 파형의 5개 구간을 한 단계씩 따라가기):

1. 구간 1 — Hold (S̅=1, R̅=1, 직전 Q=0 가정): 윗 NAND의 입력은 (1, Q̅=1)이므로 출력 = NOT(1·1) = 0. 아랫 NAND의 입력은 (Q=0, 1)이므로 출력 = NOT(0·1) = 1. 즉 Q=0, Q̅=1이 자기 일관(self-consistent)되며 그대로 유지됩니다. 이 휴지 상태가 "메모리 셀의 1비트"가 되는 핵심입니다.
2. 구간 2 — Set 펄스 (S̅=0, R̅=1): 윗 NAND의 한 입력이 0이 되었으므로 다른 입력에 무관하게 출력은 1로 강제됩니다(NAND 규칙: 0 한 개만 있어도 출력 1). 따라서 Q=1. 그러면 아랫 NAND의 한 입력이 Q=1이 되고 다른 입력 R̅=1이므로 출력 = NOT(1·1) = 0. 즉 Q̅=0이 됩니다. 이렇게 (Q, Q̅) = (1, 0)이 안정화됩니다.
3. 구간 3 — Hold 복귀 (S̅=1, R̅=1): S̅가 1로 돌아왔지만 윗 NAND의 다른 입력이 Q̅=0이므로 출력 = NOT(1·0) = 1로 그대로 유지. 아랫 NAND도 (Q=1, R̅=1) → 출력 0 그대로 유지. 결과: (1, 0) 보존. Set 펄스의 효과가 자기 유지된 것입니다.
4. 구간 4 — Reset 펄스 (S̅=1, R̅=0): 아랫 NAND의 한 입력이 0이 되어 출력은 1로 강제됩니다 → Q̅=1. 그러면 윗 NAND의 두 입력이 (1, 1)이 되어 출력 = 0 → Q=0. (Q, Q̅) = (0, 1) 안정화.
5. 구간 5 — Hold 복귀 (S̅=1, R̅=1): R̅가 1로 돌아와도 (Q=0, Q̅=1)이 자기 일관되어 그대로 유지. 새 0의 메모리 상태가 영구히 보존됩니다.
6. 금지 상태 (S̅=0, R̅=0): 두 NAND 모두 한 입력이 0이므로 두 출력이 동시에 1이 됩니다. 그러나 Q와 Q̅는 보수 관계여야 하므로 정의가 깨집니다. 더 큰 문제는 두 입력이 동시에 0→1로 풀릴 때 어느 쪽이 먼저 회복되느냐가 출력을 결정해 결과가 비결정적(Non-deterministic)이 된다는 점이며, 이를 "경쟁 상태(Race Condition)"라 합니다. 이 때문에 동기 회로에서는 SR 래치 대신 D 플립플롭을 선호합니다.

NOR 버전과의 비교 한눈에:

커널/실무 연결: NAND 기반 SR 래치 두 개가 마주 보면 정확히 SRAM의 6트랜지스터(6T) 비트 셀이 됩니다. CPU L1/L2 캐시의 모든 비트는 이 회로의 직접적인 응용입니다. 또한 키 입력 디바운싱(Switch Debouncing) 회로, 인터럽트 래치(IRQ Latched Status Register), GPIO 입력 캡처 회로의 기본 단위로 쓰입니다. 커널의 readl()로 상태 레지스터를 읽고 비트가 1이라면, 그 비트는 보통 이런 SR 래치 한 개에 캡처되어 있다가 소프트웨어가 클리어 비트를 쓸 때까지 보존된 상태입니다.

예시 4: 마스터-슬레이브 D 플립플롭 — 래치 두 개로 만든 에지 트리거

본문 D 래치에서 D 플립플롭으로 절에서 마스터-슬레이브(Master-Slave) 구성이 에지 트리거를 만든다고 설명했습니다. 여기서는 두 D 래치가 어떻게 연결되어 클록의 상승 에지에서만 데이터가 통과되는지 구체적인 회로도와 타이밍으로 풀어 봅니다.

핵심 아이디어: D 래치는 활성화(Enable)된 동안 입력이 출력을 따라가는(transparent) 소자입니다. 만약 두 래치를 직렬로 연결하고 각 래치의 활성화 신호를 반대 위상(Opposite Phase)의 클록으로 제어하면, 어느 시점에도 정확히 한 래치만 투명해지므로 입력이 출력까지 한 번에 통과하는 것을 막을 수 있습니다. 이 "통과 차단" 효과가 에지 트리거 동작을 만듭니다.

단계별 신호 풀이 (위 파형을 한 클록 주기씩 따라가기):

1. CLK = 0인 구간 (반주기): NOT을 통과한 마스터 EN = 1이 되어 마스터 래치는 투명. D의 모든 변화가 즉시 Qm로 따라갑니다. 동시에 슬레이브 EN = 0이므로 슬레이브는 닫혀 있고, 그 출력 Q는 직전 값을 그대로 유지합니다. 즉, 이 반주기 동안 D는 마스터까지만 들어오고 Q에는 영향을 주지 않습니다.
2. 상승 에지 (CLK 0→1) 직전: 에지가 발생하기 직전의 D 값이 Qm에 그대로 잡혀 있습니다. 이 값이 다음 단계로 "촬영(Sampled)"될 값입니다. 이 시점이 바로 셋업 시간(Setup Time, t_su) 윈도가 끝나는 지점입니다.
3. 상승 에지 (CLK 0→1): 마스터 EN이 1→0으로 바뀌어 마스터가 잠깁니다(닫힘). 거의 동시에 슬레이브 EN이 0→1로 바뀌어 슬레이브가 투명해집니다. 두 EN 사이의 타이밍 갭은 인버터(NOT)의 전파 지연(Propagation Delay)으로 보장됩니다. 슬레이브가 열린 순간, 마스터는 이미 잠겼으므로 잠긴 마스터 출력 Qm가 슬레이브의 D로 들어가 Q에 그대로 전달됩니다.
4. CLK = 1인 구간 (다음 반주기): 슬레이브 EN = 1이지만, 슬레이브 D에 들어오는 값은 잠긴 마스터의 Qm 그대로이므로 Q 출력은 더 이상 변하지 않습니다. 동시에 마스터 EN = 0이라 D의 새로운 변화는 마스터에 전혀 들어가지 않습니다. 결과적으로 이 반주기 동안 Q는 안정적으로 유지됩니다.
5. 하강 에지 (CLK 1→0): 슬레이브가 다시 잠기고 마스터가 다시 열립니다. 슬레이브가 잠힌 시점에 Q는 그 직전 값을 영구히 보존합니다. 마스터는 다시 D를 따라가지만 Q에는 영향이 없으므로 외부에서 보면 Q는 다음 상승 에지까지 그대로 유지됩니다.
6. 핵심 통찰: 두 래치가 직렬로 연결되어 있고 EN 신호가 정확히 반대 위상으로 켜지므로, 어느 시점에도 D → Q의 직접 경로(Combinational Path)가 한 번에 열리지 않습니다. 입력은 반드시 마스터 → (에지 순간 잠금/해제 교환) → 슬레이브의 두 단계를 거치므로 결과적으로 클록 한 에지마다 정확히 1번씩만 D가 Q로 전달됩니다.

왜 이렇게 만드는가: 만약 단일 D 래치만 사용한다면 클록이 High인 동안 D가 변할 때마다 Q도 함께 변해버려, 다음 단의 회로가 같은 클록 주기 안에서 잘못된 값을 받을 수 있습니다(이를 "Race-through" 또는 1-clock-cycle hazard라 합니다). 마스터-슬레이브 구조는 입력 캡처 시점을 한 점(에지)으로 한정하여 동기 회로의 시간 모델을 깨끗하게 만듭니다.

변형들: 같은 두-래치 원리를 다른 게이트 조합으로 구현한 것이 흔합니다. (1) 전송 게이트(Transmission Gate) 기반 — 두 인버터 + 두 패스 게이트, CMOS 표준 셀에서 면적이 작아 가장 흔히 사용. (2) NAND 6개 기반 — 정적 CMOS 표준 셀의 정형화된 구현, 글리치 회복력이 우수. (3) 음 에지 트리거(Negative Edge) — NOT의 위치를 슬레이브 쪽으로 옮기면 된다.

커널/실무 연결: CPU 레지스터 파일의 모든 비트, 파이프라인 레지스터, 캐시 태그 비트, GPIO 출력 래치, UART 송신 시프트 레지스터의 모든 1비트가 마스터-슬레이브 D 플립플롭입니다. 커널 코드에서 writel(val, reg)로 MMIO 레지스터에 값을 쓸 때, 그 값이 디바이스의 D 플립플롭 뱅크에 캡처되는 시점이 정확히 다음 버스 클록의 상승 에지입니다. CDC(Clock Domain Crossing) 절에서 본 2-FF 동기화기(Synchronizer)도 이 마스터-슬레이브 D-FF를 두 개 직렬로 연결한 것이며, 메타안정성(Metastability)이 확률적으로 해소되는 시간 윈도가 곧 한 클록 주기입니다.

예시 5: 2:4 디코더 (Gate-Level, with Enable)

디코더(Decoder)는 n비트 입력을 2ⁿ개의 출력 라인 중 정확히 하나만 활성화하는 회로입니다. 본문 디코더 절에서 3:8 디코더의 블록 다이어그램을 보았는데, 여기서는 가장 작은 2:4 디코더를 게이트로 직접 풀어 어떻게 "주소(Address) → 칩 선택(Chip Select)"이 만들어지는지 봅니다.

핵심 관찰: 2비트 입력 A1, A0의 4가지 조합 (00, 01, 10, 11)에 대해 각각 출력 Y0, Y1, Y2, Y3 중 하나만 1이 되어야 합니다. 그리고 칩 활성화 신호(EN)가 0일 때는 모든 출력을 0으로 강제해야 합니다(메모리/주변장치가 비활성 상태).

Y0 = A1̅ · A0̅ · EN
Y1 = A1̅ · A0  · EN
Y2 = A1  · A0̅ · EN
Y3 = A1  · A0  · EN

구현: 2개의 NOT(반전)으로 A1̅, A0̅를 만들고, 각 출력마다 3입력 AND 게이트 1개로 해당 항을 평가합니다. EN은 4개의 AND 모두에 공통 입력으로 들어갑니다.

단계별 신호 풀이 (입력 EN=1, A1=1, A0=0인 경우 — 주소 10₂ = 2₁₀ 선택):

1. 입력 분배: A1=1이 회로 좌상단에서 들어와 두 갈래로 나뉩니다 — 하나는 NOT 게이트로 들어가 A1̅=0을 만들고, 다른 하나는 그대로 "A1 rail"이라는 가로 신호선으로 오른쪽까지 전파됩니다. A0=0도 같은 방식으로 A0̅=1과 A0 rail을 만듭니다. EN=1은 별도의 가로 rail로 4개의 AND 모두에 공통 분배됩니다.
2. AND0 평가 (Y0 = A1̅ · A0̅ · EN): 입력은 (0, 1, 1). 0이 하나라도 있으면 AND 출력은 0 → Y0=0.
3. AND1 평가 (Y1 = A1̅ · A0 · EN): 입력은 (0, 0, 1). Y1=0.
4. AND2 평가 (Y2 = A1 · A0̅ · EN): 입력은 (1, 1, 1). 모두 1 → Y2=1. 정확히 주소 10₂에 해당하는 출력만 활성화됩니다.
5. AND3 평가 (Y3 = A1 · A0 · EN): 입력은 (1, 0, 1). Y3=0.
6. EN=0 효과: EN을 0으로 바꾸는 순간 4개 AND 모두 한 입력이 0이 되므로 모든 출력이 즉시 0이 됩니다. 즉 EN=0은 "모든 칩을 강제로 비활성화"하는 마스터 셧다운 스위치 역할입니다. 이 EN 신호는 메모리 컨트롤러가 리프레시(Refresh) 사이클이나 휴지(Idle) 상태에서 모든 메모리 칩을 안전하게 OFF시키는 데 사용됩니다.

n비트 디코더로 확장: 같은 패턴을 3:8 디코더로 확장하면 NOT 3개 + 4입력 AND 8개로, 4:16 디코더는 NOT 4개 + 5입력 AND 16개로 늘어납니다. 큰 디코더는 보통 두 단계의 작은 디코더로 분해해 게이트 수를 절약합니다(예: 4:16 = 2개 2:4 디코더 + 2×2 그리드의 AND 게이트).

커널/실무 연결: 디코더는 메모리 매핑 I/O(MMIO)의 물리적 토대입니다. CPU가 32비트 주소 버스에 0x4000_0000을 출력하면, 보드의 디코더 회로가 상위 비트 4'b0100을 보고 "이건 GPIO 컨트롤러 영역"이라고 판단하여 GPIO 칩의 CS#(Chip Select) 핀만 활성화합니다. 커널의 ioremap(0x40000000, 0x1000) 호출은 결국 CPU가 이 주소 범위로 트랜잭션(Transaction)을 보내고, 보드의 디코더가 그 트랜잭션을 올바른 디바이스로 라우팅(Routing)하도록 만드는 행위입니다. PCI/PCIe BAR(Base Address Register), DRAM의 뱅크/랭크 선택, 인터럽트 컨트롤러의 IRQ 라인 선택 모두 디코더가 핵심 회로입니다.

예시 6: 4비트 동기 업 카운터 (Synchronous Up Counter)

본문 4비트 이진 카운터 절에서는 T 플립플롭을 직렬로 연결한 리플 카운터(Ripple Counter)를 보았습니다. 리플 카운터는 회로가 단순하지만 각 단계마다 전파 지연(Propagation Delay)이 누적되어 상위 비트가 늦게 변하는 단점이 있습니다(예: 0111 → 1000 천이에서 4단계 지연). 이번 예시는 모든 비트가 같은 클록의 같은 에지에서 동시에 갱신되는 동기 카운터(Synchronous Counter)입니다.

설계 원리: 카운터 i번째 비트 Q_i는 그 아래 비트들이 모두 1일 때만 토글(Toggle)해야 합니다. 즉:

T0 = 1
T1 = Q0
T2 = Q1 · Q0
T3 = Q2 · Q1 · Q0

이 토글 조건은 정확히 "리플 캐리(Ripple Carry)"의 조합 등가식으로, AND 체인(Chain) 한 단으로 풀립니다. 모든 T-FF가 같은 CLK 신호에 묶여 있으므로 출력 변화가 동시에 발생합니다.

리플 카운터 vs 동기 카운터 비교:

단계별 신호 풀이 (현재 카운트 = 0011, 다음 클록 에지에서의 동작 추적):

1. 현재 상태: Q3Q2Q1Q0 = 0011 (10진수 3). T-FF의 토글 입력 상태를 평가합니다.
2. T0 = 1: 항상 1이므로 다음 에지에서 Q0는 무조건 토글 → 현재 1 → 0이 될 예정.
3. T1 = Q0 = 1: Q0가 1이므로 T1=1 → 다음 에지에서 Q1도 토글 → 현재 1 → 0이 될 예정.
4. T2 = Q1 · Q0 = 1 · 1 = 1: 두 비트 모두 1이므로 T2=1 → 다음 에지에서 Q2도 토글 → 현재 0 → 1이 될 예정.
5. T3 = Q2 · T2 = 0 · 1 = 0: Q2가 0이므로 AND chain이 끊김 → T3=0 → Q3는 변하지 않음 (현재 0 유지).
6. 다음 클록의 상승 에지(↑): 4개 FF가 동시에 자신의 T 입력에 따라 갱신됩니다. 결과: Q3Q2Q1Q0 = 0100 (10진수 4). 즉 0011 + 1 = 0100, 정확히 +1 동작.
7. 핵심 통찰 — 동시성: 만약 이게 리플 카운터였다면 0011 → 0010 → 0000 → 0100 의 중간 단계를 거치면서 Q0의 변화가 Q1을 통해, Q1의 변화가 Q2를 통해, Q2의 변화가 Q3로 천이가 전파되었을 것입니다. 동기 카운터는 모든 FF가 같은 클록을 받기 때문에 외부에서 보면 0011 → 0100이 한 번에 일어나며, 글리치를 절대 보이지 않습니다.

커널/실무 연결: CPU 내부의 PC(Program Counter), 사이클 카운터(rdtsc의 실체), 성능 카운터(PMC), DMA 전송 카운터, 타이머/워치독 카운터는 모두 동기 카운터입니다. 리플 카운터의 글리치는 비동기 입력으로 카운터 값을 읽는 회로에서 잘못된 값을 캡처할 위험이 있어, 멀티비트 카운터는 거의 항상 동기로 만듭니다. 커널의 jiffies 변수도 하드웨어 타이머 인터럽트가 갱신하지만, 그 인터럽트의 주기를 만드는 하드웨어 타이머 자체가 동기 카운터입니다. 원자적 연산(Atomic Operation)의 atomic_inc()를 SMP에서 안전하게 만드는 LOCK 접두사는, 메모리 컨트롤러 내부의 카운터/주소 비교기가 글리치 없이 동기적으로 동작해야 함을 전제합니다.

예시 7: 1비트 ALU 슬라이스 — 가산기 + 논리 게이트 + MUX의 결합

ALU(Arithmetic Logic Unit)는 한 클록 사이클에 산술/논리 연산을 수행하는 CPU의 핵심 회로입니다. 본문 ALU 블록 다이어그램에서 추상 블록을 보았는데, 여기서는 가장 작은 단위인 1비트 슬라이스(Slice)를 풀어 봅니다. 32비트 ALU는 이 슬라이스를 32개 옆으로 늘여 놓고 캐리만 옆으로 전파하면 만들어지므로, 1비트만 정확히 이해하면 전체가 이해됩니다.

이 슬라이스는 4개의 연산을 지원합니다 (Op[1:0]이 선택):

• 00: AND (A & B)
• 01: OR (A | B)
• 10: XOR (A ^ B)
• 11: ADD (A + B + Cin) — Binvert=1 + Cin0=1로 묶으면 SUB도 같은 회로