RAPL & powercap

Linux powercap 프레임워크와 Intel RAPL의 실전 활용을 다룹니다. package/core/uncore/DRAM 도메인별 에너지 카운터 해석, PL1·PL2·time window 기반 전력 제한 모델, MSR·sysfs·hwmon 인터페이스 사용법, thermal·cpufreq와의 상호작용, 전력 캡 적용 시 성능 회귀 검증, 데이터센터 전력 예산 운영 시나리오와 모니터링 지표까지 종합적으로 정리합니다.

powercap & RAPL

powercap 프레임워크는 전력 상한(power capping)을 설정하는 통합 인터페이스를 제공합니다. 가장 대표적인 백엔드는 Intel/AMD의 RAPL(Running Average Power Limit)로, 프로세서 패키지·코어·메모리 등 전력 도메인별 에너지 소비를 모니터링하고 제한할 수 있습니다.

powercap/RAPL 아키텍처

RAPL은 하드웨어 MSR(또는 TPMI)에서 에너지 카운터와 전력 제한을 읽고 쓰는 커널 드라이버를 통해 powercap 프레임워크에 등록됩니다. 사용자 공간(User Space)은 sysfs 또는 perf 이벤트를 통해 접근합니다.

RAPL 도메인

RAPL은 프로세서 내부를 여러 전력 도메인(power domain)으로 분리하여 도메인별 에너지 측정과 전력 제한을 제공합니다. 지원 도메인은 프로세서 세대에 따라 다릅니다.

도메인별 전력 분포

워크로드 유형에 따라 도메인별 전력 소비 비중이 크게 달라집니다. 다음은 실제 측정 데이터입니다:

측정 환경: Intel Core i7-1165G7 (Tiger Lake, 28W TDP), DDR4-3200 16GB, 유휴 배경 프로세스(Process) 최소화

RAPL MSR 레지스터 완전 참조

RAPL은 MSR(Model-Specific Register)을 통해 에너지 카운터, 전력 제한, 단위 정보에 접근합니다. 각 도메인별로 별도의 MSR 주소가 할당되며, 비트 필드 레이아웃은 도메인 간에 유사한 구조를 공유합니다.

MSR_RAPL_POWER_UNIT (0x606) 비트 필드

MSR_PKG_POWER_LIMIT (0x610) 비트 필드

# MSR 직접 읽기 예제 (msr-tools 패키지 필요)
sudo modprobe msr

# MSR_RAPL_POWER_UNIT 읽기
sudo rdmsr 0x606
# 예: a0e03  →  bits[3:0]=3, bits[12:8]=0xe(14), bits[19:16]=0xa(10)
# Power Unit = 1/2^3 = 0.125 W
# Energy Unit = 1/2^14 = 61.0 μJ (서버)  또는 1/2^16 = 15.3 μJ (클라이언트)
# Time Unit = 1/2^10 = 976.6 μs

# 비트 필드 추출 예제
UNIT=$(sudo rdmsr 0x606)

# Power Unit 추출 (bits 3:0)
POWER_UNIT=$(( 0x${UNIT} & 0xF ))
echo "Power Unit: 1/2^${POWER_UNIT} W = $(echo "scale=4; 1/2^${POWER_UNIT}" | bc) W"

# Energy Unit 추출 (bits 12:8)
ENERGY_UNIT=$(( (0x${UNIT} >> 8) & 0x1F ))
echo "Energy Unit: 1/2^${ENERGY_UNIT} J"

# Time Unit 추출 (bits 19:16)
TIME_UNIT=$(( (0x${UNIT} >> 16) & 0xF ))
echo "Time Unit: 1/2^${TIME_UNIT} s"

# PL1/PL2 비트 필드 조작
PL=$(sudo rdmsr 0x610)

# PL1 값 추출 (bits 14:0)
PL1_RAW=$(( 0x${PL} & 0x7FFF ))
PL1_W=$(echo "scale=2; ${PL1_RAW} * 0.125" | bc)
echo "PL1: ${PL1_W} W (raw: ${PL1_RAW})"

# PL1 Enable 확인 (bit 15)
PL1_EN=$(( (0x${PL} >> 15) & 1 ))
echo "PL1 Enabled: ${PL1_EN}"

# Lock 비트 확인 (bit 63)
LOCK=$(( (0x${PL} >> 63) & 1 ))
echo "Lock: ${LOCK} (1이면 BIOS가 잠금, 수정 불가)"

에너지 카운터: 단위 변환·오버플로

RAPL 에너지 카운터(MSR_*_ENERGY_STATUS)는 32비트 카운터로, MSR_RAPL_POWER_UNIT에서 정의된 에너지 단위만큼 증가합니다. 카운터가 최대값에 도달하면 0으로 랩어라운드(wrap-around)하므로, 정확한 에너지 측정을 위해 오버플로 처리가 필수적입니다.

/* 에너지 단위 변환 — MSR 원시 값 → μJ */
static u64 rapl_raw_to_uj(u32 raw, u32 energy_unit)
{
    /*
     * energy_unit = MSR_RAPL_POWER_UNIT bits[12:8]
     * 에너지 단위 = 1 / 2^energy_unit (줄)
     * μJ 변환 = raw × (1 / 2^energy_unit) × 1000000
     *         = raw × 1000000 >> energy_unit
     */
    return (u64)raw * 1000000ULL >> energy_unit;
}

/* 예시: energy_unit=16, raw=0x10000 (65536)
 * = 65536 × 1000000 / 65536 = 1000000 μJ = 1 J */

/* 오버플로 처리 — 32비트 카운터 랩어라운드 감지 */
static u64 rapl_energy_delta(u32 curr, u32 prev, u32 energy_unit)
{
    u32 delta;

    if (curr >= prev) {
        delta = curr - prev;
    } else {
        /* 오버플로 발생: max_value - prev + curr + 1 */
        delta = (0xFFFFFFFF - prev) + curr + 1;
    }

    return rapl_raw_to_uj(delta, energy_unit);
}

/* 커널 intel_rapl_common.c에서의 실제 구현:
 * rapl_compute_energy_delta()는 이전 값과 현재 값을 비교하여
 * 자동으로 오버플로를 감지하고 올바른 delta를 계산합니다. */

# 셸에서 에너지 delta 계산 (오버플로 처리 포함)
MAX_ENERGY=$(cat /sys/class/powercap/intel-rapl:0/max_energy_range_uj)

E1=$(cat /sys/class/powercap/intel-rapl:0/energy_uj)
sleep 5
E2=$(cat /sys/class/powercap/intel-rapl:0/energy_uj)

if [ $E2 -ge $E1 ]; then
    DELTA=$(( E2 - E1 ))
else
    # 오버플로 발생
    DELTA=$(( MAX_ENERGY - E1 + E2 ))
fi

WATTS=$(( DELTA / 5000000 ))
echo "5초간 소비: $(( DELTA / 1000000 )) J, 평균 전력: ${WATTS} W"

PL1/PL2/PL3/PL4 전력 제한 계층

RAPL은 최대 4단계의 전력 제한(Power Limit)을 제공합니다. 각 단계는 허용 전력과 시간 윈도우가 다르며, 하드웨어가 자율적으로 스로틀링을 적용합니다.

PL 전력 제한 타임라인

다음 다이어그램은 워크로드 시작 시 PL1/PL2/PL4가 시간에 따라 어떻게 작동하는지 보여줍니다:

/* powercap sysfs에서 PL1/PL2 확인 및 설정 */

# PL1 (constraint_0) 확인
cat /sys/class/powercap/intel-rapl:0/constraint_0_name          # "long_term"
cat /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw  # 현재 PL1 (μW)
cat /sys/class/powercap/intel-rapl:0/constraint_0_time_window_us  # 시간 윈도우 (μs)

# PL2 (constraint_1) 확인
cat /sys/class/powercap/intel-rapl:0/constraint_1_name          # "short_term"
cat /sys/class/powercap/intel-rapl:0/constraint_1_power_limit_uw

# PL1을 15W로 설정 (root 권한 필요)
echo 15000000 > /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw

powercap sysfs 인터페이스

RAPL 커널 드라이버 구조

커널의 RAPL 지원은 공통 로직과 하드웨어 백엔드로 분리된 모듈러 구조입니다.

/* intel_rapl_common.c — 핵심 구조체 */
struct rapl_domain {
    const char          *name;
    enum rapl_domain_type id;        /* RAPL_DOMAIN_PACKAGE, PP0, PP1, DRAM, PLATFORM */
    u64                  energy_unit;  /* 에너지 단위 (MSR_RAPL_POWER_UNIT에서 파생) */
    u64                  power_unit;   /* 전력 단위 */
    struct powercap_zone power_zone;  /* powercap 프레임워크 zone */
    struct rapl_package  *rp;         /* 소속 패키지 */
};

struct rapl_package {
    unsigned int          id;          /* 패키지(소켓) ID */
    unsigned int          nr_domains;  /* 이 패키지의 도메인 수 */
    struct rapl_domain    *domains;    /* 도메인 배열 */
    struct rapl_if_priv  *priv;       /* 백엔드별 private 데이터 */
};

# RAPL 모듈 로드 확인
lsmod | grep rapl
# intel_rapl_msr         20480  0
# intel_rapl_common      36864  1 intel_rapl_msr
# powercap               16384  1 intel_rapl_common

# 에너지 단위 확인 (MSR_RAPL_POWER_UNIT, 606h)
rdmsr 0x606
# 결과 해석: bits[12:8]=에너지 단위, bits[3:0]=전력 단위, bits[19:16]=시간 단위

powercap 드라이버 작성 가이드

커널의 powercap 프레임워크는 RAPL 외에도 커스텀 전력 상한 백엔드를 등록할 수 있는 API를 제공합니다. FPGA 전력 관리, 배터리 기반 시스템, 또는 BMC 연동 전력 제어 등을 구현할 때 powercap 드라이버를 작성하면 표준 sysfs 인터페이스를 자동으로 제공받습니다.

/* 최소 powercap 드라이버 스켈레톤 */
#include <linux/module.h>
#include <linux/powercap.h>

static struct powercap_control_type *my_ctrl;
static struct powercap_zone my_zone;
static u64 my_energy_uj;
static u64 my_power_limit_uw = 50000000; /* 50W 기본값 */

/* zone ops 구현 */
static int my_get_energy(struct powercap_zone *z, u64 *uj) {
    *uj = my_energy_uj;  /* 실제로는 하드웨어 레지스터 읽기 */
    return 0;
}

static int my_get_max_energy(struct powercap_zone *z, u64 *uj) {
    *uj = 262143328850;  /* 오버플로 범위 */
    return 0;
}

static struct powercap_zone_ops my_zone_ops = {
    .get_energy_uj       = my_get_energy,
    .get_max_energy_range_uj = my_get_max_energy,
};

/* constraint ops 구현 — PL1에 해당 */
static int my_set_power_limit(struct powercap_zone *z, int cid, u64 uw) {
    my_power_limit_uw = uw;
    /* 하드웨어에 전력 제한 적용 */
    pr_info("my_powercap: power limit set to %llu uW\n", uw);
    return 0;
}

static int my_get_power_limit(struct powercap_zone *z, int cid, u64 *uw) {
    *uw = my_power_limit_uw;
    return 0;
}

static const char *my_get_name(struct powercap_zone *z, int cid) {
    return "long_term";
}

static struct powercap_zone_constraint_ops my_const_ops = {
    .set_power_limit_uw  = my_set_power_limit,
    .get_power_limit_uw  = my_get_power_limit,
    .get_name            = my_get_name,
};

/* 모듈 초기화/정리 */
static int __init my_powercap_init(void)
{
    /* 1. control type 등록 */
    my_ctrl = powercap_register_control_type(NULL, "my-driver", NULL);
    if (IS_ERR(my_ctrl))
        return PTR_ERR(my_ctrl);

    /* 2. zone 등록 (부모 zone = NULL → 최상위) */
    if (!powercap_register_zone(&my_zone, my_ctrl,
            "zone-0",     /* zone 이름 */
            NULL,          /* 부모 zone (없으면 최상위) */
            &my_zone_ops,  /* zone 콜백 */
            1,             /* constraint 수 */
            &my_const_ops  /* constraint 콜백 */
    )) {
        powercap_unregister_control_type(my_ctrl);
        return -ENODEV;
    }
    /* → /sys/class/powercap/my-driver:0/ 자동 생성 */
    pr_info("my_powercap: registered\n");
    return 0;
}

static void __exit my_powercap_exit(void)
{
    powercap_unregister_zone(my_ctrl, &my_zone);
    powercap_unregister_control_type(my_ctrl);
}

module_init(my_powercap_init);
module_exit(my_powercap_exit);
MODULE_LICENSE("GPL");

TPMI (Topology Aware Register and PM Capsule Interface)

TPMI는 Intel Meteor Lake(클라이언트, 2023) 및 Sapphire Rapids(서버, 4세대 Xeon) 이후 도입된 MMIO 기반 PM 레지스터 인터페이스입니다. PCIe 표준 기반의 아키텍처 모델로 설계되어, 기존 MSR의 모델별 코드 유지보수 부담을 줄이고 멀티 다이/칩렛 아키텍처에서 다이별(per-die) 세밀한 전력 관리를 지원합니다. Granite Rapids(Xeon 6 P-core), Sierra Forest(Xeon 6 E-core), Clearwater Forest 등 후속 세대에서 전면 채택되었습니다.

TPMI vs MSR 비교

TPMI 아키텍처

TPMI는 PCI VSEC(Vendor Specific Extended Capability, ID=66)를 통해 발견됩니다. Intel VSEC 드라이버(intel_vsec.c)가 OOB(Out-of-Band) PCI 디바이스의 VSEC/DVSEC 구조를 스캔하여 TPMI를 감지하면, auxiliary 버스(Bus)에 TPMI 코어 디바이스를 생성합니다. TPMI 코어는 VSEC 헤더의 tBIR(BAR Indicator Register) 필드로 대상 PCI BAR를 식별하고, Address 필드로 BAR 내 PFS 시작 오프셋(Offset)을 계산합니다.

PCI VSEC 발견 및 PFS 파싱

TPMI는 PCIe 설정 공간의 VSEC(Vendor Specific Extended Capability)를 통해 발견됩니다. Intel VSEC 드라이버(intel_vsec.c)가 TPMI 타입의 VSEC를 감지하면 TPMI 코어 드라이버를 로드하고, TPMI 코어는 MMIO에 매핑된 PFS(PM Feature Structure) 테이블을 파싱합니다.

/* PFS (PM Feature Structure) 엔트리 — 하드웨어 비트필드 레이아웃 */
/* drivers/platform/x86/intel/vsec_tpmi.c (커널 6.13+, 이전: tpmi.c) */
struct intel_tpmi_pfs_entry {
    u64 tpmi_id:8;       /* PM 기능 식별자 (0=RAPL, 2=UFS, 5=SST ...) */
    u64 num_entries:8;  /* 인스턴스 수 (전력 도메인/다이 수와 대응) */
    u64 entry_size:16;  /* 인스턴스 MMIO 블록 크기 (32비트 워드 단위) */
    u64 cap_offset:16;  /* PM_Features 베이스로부터 오프셋 (KB 단위) */
    u64 attribute:2;    /* 속성 플래그 (읽기 전용, 잠금 등) */
    u64 reserved:14;
} __packed;

/* TPMI 코어의 PFS 파싱 흐름 */
tpmi_pfs_init(tpmi_info):
    /* 1. PCI BAR0에서 PFS 헤더 읽기 */
    pfs_start = devm_ioremap_resource(dev, &pci_resource);

    /* 2. PFS 엔트리 순회하며 기능 열거 */
    for (i = 0; i < pfs_count; i++) {
        read_pfs_entry(&pfs[i]);
        /* 3. 기능별 MMIO 영역 매핑 */
        feature_mem = pfs_start + pfs[i].cap_offset;
        /* 4. auxiliary 디바이스 생성 (intel_rapl_tpmi, isst_tpmi 등) */
        intel_vsec_add_aux(dev, NULL, &feature_info, name);
    }

TPMI Feature ID 매핑

각 PM 기능은 고유한 TPMI ID를 가지며, PFS 테이블에서 이 ID를 통해 발견됩니다. 커널은 ID에 따라 해당 feature 드라이버의 auxiliary 디바이스를 생성합니다.

TPMI 코어 구조체(Struct)

/* include/linux/intel_tpmi.h — TPMI API 핵심 구조체 */

/* Feature 드라이버가 TPMI 코어에서 받는 플랫폼 정보 */
struct intel_tpmi_plat_info {
    u8  package_id;        /* CPU 소켓(패키지) ID */
    u8  bus_number;        /* PCI 버스 번호 */
    u8  device_number;     /* PCI 디바이스 번호 */
    u8  function_number;   /* PCI 펑션 번호 */
    u8  segment;           /* PCI 세그먼트 ID */
    u8  partition;          /* 패키지 파티션 ID */
    u16 cdie_mask;          /* 현재 파티션의 컴퓨트 다이 비트맵 */
};

/* TPMI 코어 내부 — 디바이스별 기능 관리 */
struct intel_tpmi_info {
    struct auxiliary_device *vsec_dev;    /* 부모 VSEC auxiliary 디바이스 */
    int                   feature_count;  /* 발견된 PM 기능 수 */
    struct intel_tpmi_pm_feature *tpmi_features; /* PM 기능 배열 */
};

/* PM 기능 인스턴스 정보 */
struct intel_tpmi_pm_feature {
    struct intel_tpmi_pfs_entry pfs_header;  /* 하드웨어 PFS 헤더 */
    unsigned int                vsec_offset; /* MMIO 시작 주소 (바이트) */
    /* vsec_offset = VSEC Address + cap_offset(KB) * 1024 */
};

/* CPU↔PCI 토폴로지 매핑 헤더 (TPMI_INFO_ID=0x81에서 읽음) */
struct tpmi_info_header {
    u64 fn:3;         /* PCI Function 번호 */
    u64 dev:5;        /* PCI Device 번호 */
    u64 bus:8;        /* PCI Bus 번호 */
    u64 pkg:8;        /* CPU Package ID */
    u64 reserved:40;
} __packed;

/* Feature 드라이버가 사용하는 TPMI API (include/linux/intel_tpmi.h) */
struct intel_tpmi_plat_info *tpmi_get_platform_data(
    struct auxiliary_device *adev);     /* 플랫폼 정보 반환 */
int tpmi_get_resource_count(
    struct auxiliary_device *adev);     /* MMIO 인스턴스 수 반환 */
struct resource *tpmi_get_resource_at_index(
    struct auxiliary_device *adev,
    int index);                          /* 인덱스별 MMIO resource 반환 */
int tpmi_get_feature_status(
    struct auxiliary_device *adev,
    int feature_id,
    bool *read_blocked,
    bool *write_blocked);               /* 기능 잠금/비활성 상태 확인 */

RAPL over TPMI (intel_rapl_tpmi.c)

Meteor Lake+에서 RAPL 레지스터는 MSR 대신 TPMI MMIO를 통해 접근합니다. intel_rapl_tpmi 드라이버는 TPMI 코어에서 RAPL 기능(ID=0)의 MMIO 영역을 받아, 기존 intel_rapl_common의 powercap 프레임워크에 MMIO 백엔드로 등록합니다. 각 RAPL 도메인의 MMIO 블록 크기는 128바이트(TPMI_RAPL_DOMAIN_SIZE)이며, 각 Power Limit이 개별 레지스터를 가집니다(기존 MSR은 PL1+PL2가 하나의 64비트 MSR에 패킹).

등록 흐름: ① TPMI 코어가 PFS에서 TPMI_ID_RAPL=0 발견 → ② auxiliary 디바이스 intel_vsec.tpmi-rapl.N 생성 → ③ intel_rapl_tpmi probe → ④ tpmi_get_resource_at_index()로 MMIO 매핑 → ⑤ rapl_add_package()로 powercap zone 등록 → ⑥ /sys/class/powercap/intel-rapl:* 노출

/* intel_rapl_tpmi.c — MMIO 기반 RAPL 백엔드 */

/* TPMI RAPL MMIO 레지스터 오프셋 (MSR 주소 대신 MMIO 오프셋 사용) */
#define TPMI_RAPL_REG_HEADER          0x00
#define TPMI_RAPL_REG_UNIT            0x08   /* 에너지/전력/시간 단위 */
#define TPMI_RAPL_REG_PL1             0x10   /* Package Power Limit 1 */
#define TPMI_RAPL_REG_PL2             0x18   /* Package Power Limit 2 */
#define TPMI_RAPL_REG_PL4             0x20   /* Package Power Limit 4 */
#define TPMI_RAPL_REG_ENERGY_STATUS   0x28   /* 에너지 카운터 */
#define TPMI_RAPL_REG_PERF_STATUS    0x30   /* 성능 스로틀 상태 */
#define TPMI_RAPL_REG_POWER_INFO     0x38   /* TDP, min/max 전력 */

/* 디바이스별 RAPL TPMI 패키지 구조체 */
struct tpmi_rapl_package {
    struct rapl_if_priv          priv;       /* RAPL 인터페이스 private */
    struct intel_tpmi_plat_info *tpmi_info; /* TPMI 플랫폼 정보 */
    struct rapl_package         *rp;        /* RAPL 패키지 포인터 */
    void __iomem               *base;      /* MMIO 베이스 주소 */
};

/* MMIO 기반 읽기 — IPI 없이 직접 접근 */
static int tpmi_rapl_read_raw(int id, struct reg_action *ra)
{
    ra->value = readq(base + ra->reg.mmio_offset);
    ra->value &= ra->mask;   /* 마스크 적용 */
    return 0;
}

/* MMIO 기반 쓰기 — read-modify-write 패턴 */
static int tpmi_rapl_write_raw(int id, struct reg_action *ra)
{
    u64 val;
    val = readq(base + ra->reg.mmio_offset);
    val &= ~ra->mask;                 /* 대상 비트 클리어 */
    val |= ra->value & ra->mask;      /* 새 값 삽입 */
    writeq(val, base + ra->reg.mmio_offset);
    return 0;
}

/* rapl_if_priv — intel_rapl_common에 TPMI 백엔드 등록 */
static struct rapl_if_priv tpmi_rapl_priv = {
    .type           = RAPL_IF_TPMI,
    .read_raw       = tpmi_rapl_read_raw,
    .write_raw      = tpmi_rapl_write_raw,
    .control_type   = NULL,    /* powercap에서 설정 */
    .reg_unit       = { .mmio_offset = TPMI_RAPL_REG_UNIT },
    .regs           = {       /* 도메인별 레지스터 매핑 */
        [RAPL_DOMAIN_PACKAGE] = {
            .pl1    = { .mmio_offset = TPMI_RAPL_REG_PL1 },
            .pl2    = { .mmio_offset = TPMI_RAPL_REG_PL2 },
            .pl4    = { .mmio_offset = TPMI_RAPL_REG_PL4 },
            .energy = { .mmio_offset = TPMI_RAPL_REG_ENERGY_STATUS },
            .info   = { .mmio_offset = TPMI_RAPL_REG_POWER_INFO },
        },
    },
};

SST (Speed Select Technology) over TPMI

Intel Speed Select Technology(SST)는 동일 CPU 내에서 코어별 차등 성능 프로파일을 제공합니다. Meteor Lake+에서 SST는 TPMI(Feature ID=5)를 통해 접근합니다.

# intel-speed-select CLI 도구로 SST 상태 확인
intel-speed-select --info
intel-speed-select perf-profile info        # SST-PP 프로파일 정보
intel-speed-select base-freq info           # SST-BF 지원 코어 확인
intel-speed-select turbo-freq info          # SST-TF 상태
intel-speed-select core-power info          # SST-CP 우선순위

# SST-CP로 특정 코어에 높은 우선순위 부여
intel-speed-select core-power assoc --clos 0 --core 0,1,2,3   # 고성능 그룹
intel-speed-select core-power assoc --clos 3 --core 4,5,6,7   # 저전력 그룹

Uncore 주파수 제어 over TPMI

TPMI 이전에는 Uncore 주파수가 패키지/다이 단위로만 제어 가능했습니다. TPMI(Feature ID=2)는 패브릭 클러스터(fabric cluster) 단위의 세밀한 Uncore 주파수 제어를 지원합니다.

PLR (Performance Limit Reasons) over TPMI

PLR(Feature ID=8)은 CPU 성능이 제한(스로틀링)되는 원인을 실시간으로 보고합니다. TPMI를 통해 debugfs에 노출되며, 성능 문제 진단에 활용됩니다.

# PLR 상태 확인 (debugfs)
ls /sys/kernel/debug/tpmi-plr/
# die0/  die1/  ...

cat /sys/kernel/debug/tpmi-plr/die0/status
# 각 비트가 스로틀링 원인을 나타냄:
# - thermal: 열 제한
# - power_limit_pl1: PL1(장기 전력) 초과
# - power_limit_pl2: PL2(단기 전력) 초과
# - electrical_design_point: 전류 한계 도달
# - turbo_transition_attenuation: 터보 전환 감쇠
# - prochot: 외부 PROCHOT# 신호

# PLR 스티키 비트 클리어 (해당 파일에 0 쓰기)
echo 0 > /sys/kernel/debug/tpmi-plr/die0/status

TPMI 커널 설정

# TPMI 관련 Kconfig 옵션
CONFIG_INTEL_VSEC=m            # Intel Vendor Specific Extended Capabilities (필수)
CONFIG_INTEL_TPMI=m            # TPMI 코어 드라이버
CONFIG_INTEL_RAPL_TPMI=m       # RAPL over TPMI 백엔드
CONFIG_INTEL_UNCORE_FREQ_TPMI=m  # Uncore 주파수 제어 over TPMI
CONFIG_INTEL_SPEED_SELECT_INTERFACE=m  # SST over TPMI

# 로드된 TPMI 모듈 확인
lsmod | grep tpmi
# intel_rapl_tpmi        16384  0
# intel_uncore_freq_tpmi 16384  0
# isst_tpmi              20480  0
# intel_tpmi             24576  3 intel_rapl_tpmi,intel_uncore_freq_tpmi,isst_tpmi
# intel_vsec             16384  1 intel_tpmi

# TPMI 디바이스 확인 (PCI VSEC)
lspci -d 8086: -vvv | grep -A5 "Vendor Specific"

TPMI 소스 트리 구조

TPMI debugfs 인터페이스

TPMI 코어 드라이버는 debugfs를 통해 PFS 테이블 덤프(Dump)와 Feature별 MMIO 원시 읽기/쓰기를 제공합니다. 주로 디버깅(Debugging)과 펌웨어 설정 확인에 사용됩니다.

# TPMI debugfs 구조
/sys/kernel/debug/tpmi-<N>/
    ├── pfs_dump                     # PFS 테이블 전체 엔트리 출력
    ├── tpmi-id-<feature_id>/
    │   ├── mem_dump                 # Feature MMIO 영역 원시 덤프 (읽기 전용)
    │   └── mem_write                # 특정 오프셋에 MMIO 쓰기 (디버그용)
    └── ...

# PFS 엔트리 확인 (어떤 PM 기능이 지원되는지)
cat /sys/kernel/debug/tpmi-0/pfs_dump

# RAPL MMIO 레지스터 원시 값 확인
cat /sys/kernel/debug/tpmi-0/tpmi-id-0/mem_dump

TPMI 커널 머지 타임라인

AMD RAPL 지원

AMD는 Zen 아키텍처(Family 17h, Ryzen 1000/EPYC 7001) 이후로 RAPL 호환 MSR을 제공합니다. 커널 intel_rapl_msr 드라이버가 AMD CPU도 지원하여 동일한 powercap sysfs 인터페이스로 접근 가능합니다.

Zen 세대별 RAPL 지원 차이

AMD PPT/STAPM 전력 관리 모델

AMD 프로세서는 Intel의 PL1/PL2와 다른 전력 관리 모델을 사용합니다. PPT(Package Power Tracking)는 소켓 전체의 전력 상한이고, STAPM(Skin Temperature Aware Power Management)는 노트북의 외부 온도(skin temperature)를 고려한 지속 전력 제한입니다. 이 값들은 RAPL MSR이 아닌 SMU(System Management Unit) 펌웨어를 통해 제어됩니다.

amd_energy hwmon 드라이버

amd_energy 드라이버는 powercap 프레임워크를 사용하지 않고 hwmon 인터페이스로 에너지 정보를 노출합니다. 소켓별, 코어별 에너지 소비를 /sys/class/hwmon/에서 확인할 수 있습니다.

# amd_energy 모듈 로드 (Family 17h/19h)
sudo modprobe amd_energy

# hwmon 인터페이스 확인
for hw in /sys/class/hwmon/hwmon*/; do
    if [ "$(cat ${hw}/name)" = "amd_energy" ]; then
        echo "Found amd_energy at ${hw}"
        ls ${hw}/energy*_input
        # energy1_input: 소켓 에너지 (μJ)
        # energy2_input ~ energyN_input: 코어별 에너지
    fi
done

# 소켓 전력 계산 (5초 간격)
E1=$(cat /sys/class/hwmon/hwmon*/energy1_input)
sleep 5
E2=$(cat /sys/class/hwmon/hwmon*/energy1_input)
echo "소켓 전력: $(( (E2 - E1) / 5000000 )) W"

Intel vs AMD 전력 관리 종합 비교

Intel과 AMD는 서로 다른 전력 관리 철학과 아키텍처를 채택하고 있습니다. Intel은 RAPL을 통한 OS 레벨의 세밀한 전력 제어를 제공하는 반면, AMD는 SMU 펌웨어 기반의 자율적 전력 관리에 초점을 맞춥니다.

# Intel: PL1을 25W로 설정 (OS 레벨 제어)
echo 25000000 > /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw
cat /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw
# 25000000 → 즉시 적용

# AMD: PPT는 BIOS에서만 설정 가능 (OS에서 읽기 전용)
cat /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw
# 0 또는 고정값 → 쓰기 불가
# AMD에서 전력 제한은 amd_pstate EPP 또는 BIOS PPT 설정 사용
echo "power" > /sys/devices/system/cpu/cpu*/cpufreq/energy_performance_preference

perf 전력 이벤트 및 모니터링 도구

# RAPL 전력 측정 (perf) — 5초간 에너지 소비 측정
perf stat -e power/energy-pkg/,power/energy-cores/,power/energy-ram/ sleep 5

# 특정 프로세스의 전력 소비 프로파일링
perf stat -e power/energy-pkg/,power/energy-cores/ -- make -j$(nproc)

# turbostat — 실시간 전력/주파수/온도 모니터링
turbostat --show Package,Core,CPU,Avg_MHz,Busy%,PkgWatt,CorWatt,RAMWatt --interval 1

# powertop — 전력 소비 분석 + 절전 추천
powertop --auto-tune    # 자동 절전 최적화 적용
powertop --csv=report.csv --time=30   # 30초 측정 후 CSV 리포트

# powercap 에너지 직접 읽기 (커스텀 스크립트용)
E1=$(cat /sys/class/powercap/intel-rapl:0/energy_uj)
sleep 5
E2=$(cat /sys/class/powercap/intel-rapl:0/energy_uj)
echo "5초간 소비: $(( (E2 - E1) / 1000000 )) J, 평균: $(( (E2 - E1) / 5000000 )) W"

실전 예제: PL1 제한 효과 측정

전력 제한(PL1)을 적용했을 때 성능과 전력의 트레이드오프를 실제로 측정해봅니다.

예제 1: PL1 제한 전후 벤치마크

#!/bin/bash
# PL1 제한 효과 비교 스크립트

# 1. 기본 PL1 확인 및 저장
RAPL_PATH="/sys/class/powercap/intel-rapl:0"
ORIG_PL1=$(cat ${RAPL_PATH}/constraint_0_power_limit_uw)
echo "원래 PL1: $(( ORIG_PL1 / 1000000 )) W"

# 2. 제한 없음 (기본값) 테스트
echo "=== 기본 설정 테스트 ==="
perf stat -e power/energy-pkg/,power/energy-cores/ \
    stress-ng --cpu 8 --timeout 30s 2>&1 | grep energy

# 3. PL1 25W로 제한
echo 25000000 > ${RAPL_PATH}/constraint_0_power_limit_uw
echo "=== PL1 25W 제한 테스트 ==="
perf stat -e power/energy-pkg/,power/energy-cores/ \
    stress-ng --cpu 8 --timeout 30s 2>&1 | grep energy

# 4. PL1 15W로 강제 제한
echo 15000000 > ${RAPL_PATH}/constraint_0_power_limit_uw
echo "=== PL1 15W 제한 테스트 ==="
perf stat -e power/energy-pkg/,power/energy-cores/ \
    stress-ng --cpu 8 --timeout 30s 2>&1 | grep energy

# 5. 원래 설정 복원
echo ${ORIG_PL1} > ${RAPL_PATH}/constraint_0_power_limit_uw
echo "PL1 복원 완료"

예상 결과:

예제 2: 프로그램별 에너지 프로파일링(Profiling)

# 컴파일 vs 압축 vs 암호화 — 에너지 소비 비교

# 컴파일 (CPU intensive)
perf stat -e power/energy-pkg/,power/energy-cores/ -- \
    make -j$(nproc) clean all

# 압축 (메모리 대역폭 intensive)
perf stat -e power/energy-pkg/,power/energy-ram/ -- \
    tar -czf archive.tar.gz /usr/share/doc

# 암호화 (CPU + 일부 메모리)
perf stat -e power/energy-pkg/,power/energy-cores/ -- \
    openssl enc -aes-256-cbc -in largefile -out largefile.enc -k password

# 결과 비교 예시:
# 컴파일:  Package 2500J, Cores 1800J, RAM 200J  → CPU 중심
# 압축:    Package 1200J, Cores  600J, RAM 400J  → 메모리 대역폭 비중 큼
# 암호화:  Package 1800J, Cores 1500J, RAM 100J  → CPU 집약적

예제 3: turbostat으로 실시간 전력 추적

# turbostat으로 PL1 제한 효과 실시간 관찰
# 터미널 1: turbostat 실행
sudo turbostat --show Package,Core,CPU,Avg_MHz,Busy%,PkgWatt,CorWatt,GFXWatt --interval 1

# 터미널 2: 부하 적용 후 PL1 변경
stress-ng --cpu 8 --timeout 120s &
sleep 30
echo 25000000 > /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw
# → turbostat에서 PkgWatt가 즉시 25W 이하로 떨어지는 것 확인
# → Avg_MHz도 함께 감소 (스로틀링)

sleep 30
echo ${ORIG_PL1} > /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw
# → PkgWatt와 Avg_MHz가 원래대로 복구

전력 제한 스로틀링 디버깅

시스템 성능이 예상보다 낮을 때, 원인이 열 제한인지 전력 제한인지를 구별하는 것이 중요합니다. Intel CPU는 MSR_CORE_PERF_LIMIT_REASONS(0x64F)와 MSR_RING_PERF_LIMIT_REASONS(0x6B1) 레지스터를 통해 스로틀링 원인을 비트 단위로 보고합니다.

# MSR_CORE_PERF_LIMIT_REASONS (0x64F) 읽기
sudo rdmsr 0x64F
# 결과를 비트별로 해석:
# bit[0]:  PROCHOT 상태 (외부 열 제한 신호)
# bit[1]:  Thermal 상태 (내부 온도 제한)
# bit[4]:  Residency State 제한
# bit[5]:  Running Average Thermal 제한
# bit[6]:  VR Thermal Alert
# bit[8]:  VR Thermal Design Current
# bit[10]: PL1 (Long-Term) 전력 제한 활성
# bit[11]: PL2 (Short-Term) 전력 제한 활성
# bit[12]: Max Turbo Limit 제한
# bit[13]: Turbo Transition Attenuation
# bit[16~25]: 로그 비트 (스티키 — 마지막 클리어 이후 누적)

# turbostat으로 스로틀링 원인 확인
sudo turbostat --show Package,Core,CPU,Avg_MHz,Busy%,PkgWatt,PkgTmp,Throttle --interval 1
# Throttle 컬럼에 표시되는 값:
# 0x0000 = 스로틀링 없음
# 0x0400 = PL1 제한
# 0x0800 = PL2 제한
# 0x0001 = PROCHOT
# 0x0002 = Thermal

# perf로 전력 제한 이벤트 추적
sudo perf trace -e power:cpu_frequency,thermal:thermal_zone_trip -- sleep 30

# ftrace로 RAPL 전력 제한 디버깅
echo 1 > /sys/kernel/debug/tracing/events/power/cpu_frequency/enable
echo 1 > /sys/kernel/debug/tracing/events/thermal/thermal_zone_trip/enable
cat /sys/kernel/debug/tracing/trace_pipe

#!/bin/bash
# 자동 스로틀링 진단 스크립트

echo "=== RAPL 스로틀링 진단 ==="

# 1. MSR 스로틀 이유 확인
LIMIT_REASONS=$(sudo rdmsr 0x64F)
echo "MSR 0x64F: 0x${LIMIT_REASONS}"

if (( 0x${LIMIT_REASONS} & 0x01 )); then echo "  [!] PROCHOT 활성"; fi
if (( 0x${LIMIT_REASONS} & 0x02 )); then echo "  [!] Thermal 제한"; fi
if (( 0x${LIMIT_REASONS} & 0x400 )); then echo "  [!] PL1 전력 제한"; fi
if (( 0x${LIMIT_REASONS} & 0x800 )); then echo "  [!] PL2 전력 제한"; fi

# 2. 현재 PL1/PL2 확인
echo "PL1: $(cat /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw) μW"
echo "PL2: $(cat /sys/class/powercap/intel-rapl:0/constraint_1_power_limit_uw) μW"

# 3. 현재 온도
for zone in /sys/class/thermal/thermal_zone*/; do
    echo "  $(cat ${zone}/type): $(cat ${zone}/temp)m°C"
done

RAPL과 thermal 서브시스템 연계

Linux thermal 프레임워크는 CPU 온도가 임계값에 도달하면 cooling device를 활성화하여 발열을 제어합니다. RAPL의 전력 제한(PL1)은 가장 효과적인 cooling 수단 중 하나이며, thermal 서브시스템과의 연계를 통해 자동화된 전력-열 관리가 가능합니다.

# intel_powerclamp — 강제 idle 삽입으로 CPU 전력/발열 감소
modprobe intel_powerclamp

# 현재 powerclamp 상태 확인
cat /sys/class/thermal/cooling_device*/type | grep -n powerclamp
# intel_powerclamp

# 최대 20% idle 시간 강제 삽입
echo 20 > /sys/class/thermal/cooling_device*/cur_state
# → CPU 사용률 최대 80%로 제한, 전력/온도 감소

# powerclamp 해제
echo 0 > /sys/class/thermal/cooling_device*/cur_state

# thermal zone과 RAPL cooling device 연계 확인
for zone in /sys/class/thermal/thermal_zone*/; do
    echo "=== $(cat ${zone}/type) ==="
    echo "  온도: $(cat ${zone}/temp) m°C"
    echo "  정책: $(cat ${zone}/policy)"
    for trip in ${zone}/trip_point_*_type; do
        idx=$(echo $trip | grep -oP 'trip_point_\K[0-9]+')
        echo "  trip ${idx}: $(cat ${trip}) @ $(cat ${zone}/trip_point_${idx}_temp)m°C"
    done
done

# power_allocator governor 사용 (IPA — Intelligent Power Allocation)
# 여러 cooling device 간 전력 예산을 비례 배분

# thermal zone에 power_allocator 정책 설정
echo "power_allocator" > /sys/class/thermal/thermal_zone0/policy

# sustainable_power 설정 (mW 단위) — 목표 열 평형 전력
echo 15000 > /sys/class/thermal/thermal_zone0/sustainable_power

# 결과: governor가 cpufreq, RAPL, fan 등에 전력을 비례 배분하여
# 목표 온도를 유지하면서 성능을 최대화

RAPL 정확도·보안·제한사항

RAPL 관련 CVE 및 사이드 채널 공격

SGX와 RAPL의 보안 관계

Intel SGX(Software Guard Extensions) 환경에서 RAPL은 특별한 보안 위험을 가집니다. SGX enclave는 메모리 암호화(Encryption)로 보호되지만, enclave 내부 연산의 전력 소비 패턴은 RAPL 카운터에 반영됩니다. PLATYPUS 공격은 이 점을 악용하여 enclave 내 AES-NI 명령어의 라운드별 전력 차이를 분석하고, 통계적 방법으로 128비트 AES 키를 복원합니다.

접근 제어 발전 이력

# 현재 perf 접근 권한 확인
cat /proc/sys/kernel/perf_event_paranoid
# 4: 모든 perf 이벤트 제한 (기본값, 일부 배포판)
# 2: 커널 이벤트 제한 (기본값)
# 1: CPU 이벤트 제한
# 0: 제한 없음
# -1: 모든 접근 허용

# RAPL 에너지 읽기가 Permission denied인 경우
sudo sysctl kernel.perf_event_paranoid=0  # 임시 해제 (재부팅 시 초기화)

# 오버플로 범위 확인
cat /sys/class/powercap/intel-rapl:0/max_energy_range_uj
# 예: 262143328850 (≈262 kJ, 150W 시 ~29분마다 오버플로)

가상화 환경 RAPL

가상머신(VM)에서 RAPL MSR에 접근하면 기본적으로 하이퍼바이저(Hypervisor)가 트랩(trap)하여 차단합니다. 이는 호스트의 전력 정보가 게스트에 노출되어 사이드 채널 공격에 악용될 수 있기 때문입니다. 그러나 클라우드 환경에서도 전력 모니터링이 필요한 경우가 있어, 제한적인 패스스루 방법이 제공됩니다.

# KVM MSR 필터 설정 — RAPL MSR 패스스루 (QEMU 6.0+)
# 주의: 보안상 프로덕션에서는 비권장
qemu-system-x86_64 \
    -cpu host \
    -accel kvm \
    # RAPL MSR 패스스루를 위한 KVM 매개변수
    -device intel-rapl,id=rapl0

# KVM ioctl을 통한 MSR 필터 설정 (커널 5.10+)
# KVM_X86_SET_MSR_FILTER로 특정 MSR만 허용
# MSR 0x611 (PKG_ENERGY_STATUS) → 읽기 허용
# MSR 0x619 (DRAM_ENERGY_STATUS) → 읽기 허용
# MSR 0x610 (PKG_POWER_LIMIT) → 차단 유지

# 게스트 VM에서 RAPL 사용 가능 여부 확인
lsmod | grep rapl
# 모듈이 없거나 에너지 값이 0이면 → 하이퍼바이저가 차단 중

cat /sys/class/powercap/intel-rapl:0/energy_uj
# Permission denied 또는 파일 미존재 → MSR 패스스루 필요

# Xen에서 RAPL 확인
xl dmesg | grep -i rapl
# Xen은 dom0에서만 RAPL 접근 허용, domU는 기본 차단

서버 전력 예산 관리 실전

데이터센터에서 전력은 가장 중요한 운영 비용 중 하나입니다. RAPL의 PL1/PL2 제어를 활용하면 랙·서버·소켓 단위의 세밀한 전력 예산(power budget) 관리가 가능합니다. 시설 전력(facility power), PDU(Power Distribution Unit), 랙, 서버, CPU 소켓까지의 계층적 전력 배분이 핵심입니다.

#!/bin/bash
# 랙 전력 예산 관리 스크립트 — RAPL PL1 동적 조정

RACK_BUDGET_W=18000      # 랙 전력 예산 (18 kW)
MARGIN_W=2000             # 안전 마진 (2 kW)
MIN_PL1_UW=80000000       # 최소 PL1 (80W)
SERVERS=("srv01" "srv02" "srv03" "srv04")

# IPMI로 현재 랙 전력 읽기
get_rack_power() {
    local total=0
    for srv in "${SERVERS[@]}"; do
        pw=$(ipmitool -H ${srv}-bmc -U admin -P pass sdr get "Total_Power" | \
             awk '/Sensor Reading/{print $4}')
        total=$(( total + pw ))
    done
    echo $total
}

# PL1 동적 감소
reduce_pl1() {
    local target_uw=$1
    for srv in "${SERVERS[@]}"; do
        ssh ${srv} "echo ${target_uw} > /sys/class/powercap/intel-rapl:0/constraint_0_power_limit_uw"
        ssh ${srv} "echo ${target_uw} > /sys/class/powercap/intel-rapl:1/constraint_0_power_limit_uw"
    done
}

# 메인 루프
while true; do
    current=$(get_rack_power)
    if [ $current -gt $(( RACK_BUDGET_W - MARGIN_W )) ]; then
        echo "[WARN] 랙 전력 ${current}W — 예산 초과 임박, PL1 감소"
        reduce_pl1 $MIN_PL1_UW
    fi
    sleep 10
done

# Redfish API로 서버 전력 제한 (BMC 지원 필요)
curl -k -u admin:pass \
  -X PATCH https://bmc-ip/redfish/v1/Chassis/1/Power \
  -H "Content-Type: application/json" \
  -d '{"PowerControl":[{"PowerLimit":{"LimitInWatts": 300}}]}'

# IPMI로 서버 전력 캡 설정
ipmitool -H bmc-ip -U admin -P pass power cap set 300
ipmitool -H bmc-ip -U admin -P pass power cap enable

# Redfish 전력 상태 조회
curl -k -u admin:pass \
  https://bmc-ip/redfish/v1/Chassis/1/Power | jq '.PowerControl[0]'

# RAPL + IPMI 통합 전력 프로파일링
# 서버 총 전력 (IPMI) vs CPU 전력 (RAPL) 비교

IPMI_POWER=$(ipmitool sdr get "Total_Power" | awk '/Reading/{print $4}')
RAPL_PKG0=$(cat /sys/class/powercap/intel-rapl:0/energy_uj)
sleep 5
RAPL_PKG0_2=$(cat /sys/class/powercap/intel-rapl:0/energy_uj)
CPU_POWER=$(( (RAPL_PKG0_2 - RAPL_PKG0) / 5000000 ))

echo "서버 총 전력: ${IPMI_POWER}W, CPU 전력: ${CPU_POWER}W"
echo "비-CPU 전력 (디스크, NIC, 팬 등): $(( IPMI_POWER - CPU_POWER ))W"

Kubernetes/컨테이너 전력 관리

클라우드 네이티브 환경에서 컨테이너별 전력 소비를 측정하고 탄소 인식 스케줄링(carbon-aware scheduling)을 구현하는 것은 지속 가능한 컴퓨팅의 핵심 과제입니다. Kepler (Kubernetes-based Efficient Power Level Exporter)는 RAPL 에너지 카운터와 eBPF를 결합하여 컨테이너/파드 단위의 전력 소비를 추정합니다.

# Kepler DaemonSet 배포 (Helm)
# helm repo add kepler https://sustainable-computing-io.github.io/kepler-helm-chart
# helm install kepler kepler/kepler --namespace kepler --create-namespace

# 또는 직접 매니페스트 배포
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kepler-exporter
  namespace: kepler
spec:
  selector:
    matchLabels:
      app: kepler
  template:
    spec:
      containers:
      - name: kepler
        image: quay.io/sustainable_computing_io/kepler:latest
        securityContext:
          privileged: true   # RAPL MSR + eBPF 접근 필요
        volumeMounts:
        - name: modules
          mountPath: /lib/modules
        - name: powercap
          mountPath: /sys/class/powercap
          readOnly: true
      volumes:
      - name: modules
        hostPath: { path: /lib/modules }
      - name: powercap
        hostPath: { path: /sys/class/powercap }

# Kepler PromQL 쿼리 — 파드별 전력 소비 (W)
# 네임스페이스별 총 전력
sum by (container_namespace) (
  rate(kepler_container_joules_total[5m])
)

# 상위 10개 파드 전력 소비
topk(10, sum by (pod_name) (
  rate(kepler_container_joules_total{container_namespace="production"}[5m])
))

# cgroup perf_event를 통한 컨테이너 에너지 측정 (수동)
# 컨테이너 cgroup 경로 확인
CGROUP=$(docker inspect --format '{{.State.Pid}}' mycontainer)
cat /proc/${CGROUP}/cgroup | grep perf_event

# cgroup v2에서 perf로 에너지 측정
perf stat -e power/energy-pkg/ --cgroup /sys/fs/cgroup/system.slice/docker-*.scope -- sleep 10

RAPL 커널 설정 및 배포판 기본값

RAPL 기능을 사용하려면 커널에서 관련 Kconfig 옵션이 활성화되어 있어야 합니다. 대부분의 주요 배포판은 RAPL을 모듈로 포함하고 있으나, 임베디드나 커스텀 커널에서는 수동 설정이 필요합니다.

# RAPL 관련 Kconfig 옵션 (make menuconfig)

# 필수
CONFIG_POWERCAP=y|m          # powercap 프레임워크 (Device Drivers → Power supply support → Power capping)
CONFIG_INTEL_RAPL_CORE=m     # RAPL 공통 코어 (intel_rapl_common)
CONFIG_INTEL_RAPL_MSR=m      # MSR 기반 백엔드 (대부분의 Intel/AMD CPU)

# 선택적
CONFIG_INTEL_RAPL_TPMI=m     # TPMI 기반 백엔드 (Meteor Lake+, Sapphire Rapids+)
CONFIG_PERF_EVENTS_INTEL_RAPL=y|m  # perf power/energy-*/ 이벤트 (CPU_SUP_INTEL 필요)
CONFIG_SENSORS_AMD_ENERGY=m  # AMD hwmon 에너지 드라이버 (HWMON 필요)

# TPMI 의존성
CONFIG_INTEL_VSEC=m          # Intel Vendor Specific Extended Capabilities
CONFIG_INTEL_TPMI=m          # TPMI 코어 드라이버

# 현재 커널의 RAPL 설정 확인
zgrep -E "RAPL|POWERCAP|AMD_ENERGY" /proc/config.gz
# 또는
grep -E "RAPL|POWERCAP|AMD_ENERGY" /boot/config-$(uname -r)

# 모듈 로드 상태 확인
lsmod | grep -E "rapl|powercap"

# 수동 모듈 로드
sudo modprobe intel_rapl_msr
sudo modprobe intel_rapl_common

# 부팅 시 자동 로드 설정
echo "intel_rapl_msr" | sudo tee /etc/modules-load.d/rapl.conf

# 문제 해결: RAPL이 동작하지 않는 경우

# 1. CPU 지원 확인
grep -c rapl /proc/cpuinfo
cat /proc/cpuinfo | head -20 | grep "model name"

# 2. 모듈 로드 실패 → dmesg 확인
dmesg | grep -i rapl
# "intel_rapl_common: Found RAPL domain package" → 정상
# "intel_rapl_msr: no valid RAPL domains" → CPU 미지원 또는 BIOS 비활성화

# 3. BIOS에서 RAPL 비활성화된 경우
# → BIOS Setup → Advanced → Power Management → RAPL → Enable

# 4. 부팅 매개변수로 강제 활성화
# GRUB_CMDLINE_LINUX에 추가:
# intel_rapl.enable=1  (일부 BIOS 잠금 우회)

참고 자료

커널 공식 문서

• Power Capping Framework — powercap sysfs 인터페이스 설계
• Intel RAPL Driver — RAPL 커널 드라이버 관리자 가이드
• Dynamic Thermal Power Management (DTPM) — 동적 열 전력 관리
• Power Allocator Governor — IPA와 전력 제한 연동

LWN.net 기사

• The power capping framework — powercap 프레임워크 도입 배경
• RAPL and running average power — RAPL MSR 활용과 전력 측정
• RAPL and power side channels — PLATYPUS 공격과 RAPL 보안 제한
• DTPM — Dynamic Thermal Power Management — 소프트웨어 기반 전력 할당

하드웨어 벤더 문서

• Intel RAPL Energy Reporting — Intel RAPL MSR 레지스터 사양 및 보안 가이드
• AMD Developer Resources — AMD RAPL 호환 MSR 문서

도구

• powercap userspace library — powercap sysfs C 라이브러리
• Scaphandre — RAPL 기반 에너지 소비 모니터링 에이전트
• turbostat — Intel CPU 전력/주파수/C-state 실시간 모니터 (tools/power/x86/turbostat/)
• perf stat -e power/energy-pkg/ — perf로 RAPL 에너지 카운터 읽기

커널 소스

• drivers/powercap/powercap_sys.c — powercap sysfs 코어
• drivers/powercap/intel_rapl_common.c — Intel RAPL 공통 로직
• drivers/powercap/intel_rapl_msr.c — RAPL MSR 백엔드
• drivers/powercap/intel_rapl_tpmi.c — RAPL TPMI 백엔드 (최신 플랫폼)
• drivers/powercap/dtpm.c — DTPM 프레임워크
• arch/x86/include/asm/msr-index.h — RAPL MSR 주소 정의

관련 문서

• 전원 관리 — cpuidle, runtime PM, genpd
• MSR — Model-Specific Register
• CPU 토폴로지 — 코어/패키지 계층
• Thermal 서브시스템 — thermal zone, cooling device, 열 관리 프레임워크
• CPU 주파수 스케일링 — cpufreq governor, intel_pstate, amd_pstate
• CPUIdle — C-state와 RAPL 전력 측정 연계
• Intel PCM — 언코어 PMU, 전력 카운터 통합 계측