Question

我有一个在Atom上运行的嵌入式Linux系统，这是一个足够新的CPU，具有一个不变的TSC（时间戳计数器），其内核在启动时测量的频率。我在自己的代码中使用TSC来保持时间（避免内核调用），我的启动代码测量TSC速率，但我宁愿只使用内核的测量。有没有办法从内核中检索这个？它不在/ proc / cpuinfo中。

Answer 1

我有一个简短的介绍，似乎没有一种内置的方法可以直接从内核获取这些信息。

然而，内核导出the symbol tsc_khz（我猜是你想要的）。您可以编写一个公开sysfs接口的小内核模块，并使用它来从用户空间读出tsc_khz的值。

如果不能编写内核模块，可以使用一些Dark Magic™直接从内核内存空间读出值。解析内核二进制文件或System.map文件以查找tsc_khz符号的位置，并从/dev/{k}mem读取它。当然，只有在内核配置了适当的选项时才能实现。

最后，通过阅读kernel source comments，看起来TSC可能在某些平台上不稳定。我不太了解x86 arch的内部工作原理，但这可能是你想要考虑的事情。

Answer 2

TSC速率与/proc/cpuinfo中的“cpu MHz”直接相关。实际上，使用的更好的数字是“bogomips”。原因是虽然TSC的频率是最大CPU频率，但当前的“cpu Mhz”可能会在调用时发生变化。

bogomips值在启动时计算。您需要根据核心数和处理器数量（即超线程数）来调整此值，这样可以得到[小数] MHz。这就是我用来做你想做的事情。

要获取处理器计数，请查找 last “processor：”行。处理器计数为<value> + 1。称之为“cpu_count”。

要获得内核数量，任何“cpu cores：”都可以。核心数量为<value>。称之为“core_count”。

所以，公式是：

smt_count = cpu_count;
if (core_count)
    smt_count /= core_count;
cpu_freq_in_khz = (bogomips * scale_factor) / smt_count;

这是从我的实际代码中提取的，如下所示。

这是我使用的实际代码。你将无法直接使用它，因为它依赖于我的样板，但它应该给你一些想法，特别是如何计算

// syslgx/tvtsc -- system time routines (RDTSC)

#include <tgb.h>
#include <zprt.h>

tgb_t systvinit_tgb[] = {
    { .tgb_val = 1, .tgb_tag = "cpu_mhz" },
    { .tgb_val = 2, .tgb_tag = "bogomips" },
    { .tgb_val = 3, .tgb_tag = "processor" },
    { .tgb_val = 4, .tgb_tag = "cpu_cores" },
    { .tgb_val = 5, .tgb_tag = "clflush_size" },
    { .tgb_val = 6, .tgb_tag = "cache_alignment" },
    TGBEOT
};

// _systvinit -- get CPU speed
static void
_systvinit(void)
{
    const char *file;
    const char *dlm;
    XFIL *xfsrc;
    int matchflg;
    char *cp;
    char *cur;
    char *rhs;
    char lhs[1000];
    tgb_pc tgb;
    syskhz_t khzcpu;
    syskhz_t khzbogo;
    syskhz_t khzcur;
    sysmpi_p mpi;

    file = "/proc/cpuinfo";

    xfsrc = fopen(file,"r");
    if (xfsrc == NULL)
        sysfault("systvinit: unable to open '%s' -- %s\n",file,xstrerror());

    dlm = " \t";

    khzcpu = 0;
    khzbogo = 0;

    mpi = &SYS->sys_cpucnt;
    SYSZAPME(mpi);

    // (1) look for "cpu MHz : 3192.515" (preferred)
    // (2) look for "bogomips : 3192.51" (alternate)
    // FIXME/CAE -- on machines with speed-step, bogomips may be preferred (or
    // disable it)
    while (1) {
        cp = fgets(lhs,sizeof(lhs),xfsrc);
        if (cp == NULL)
            break;

        // strip newline
        cp = strchr(lhs,'\n');
        if (cp != NULL)
            *cp = 0;

        // look for symbol value divider
        cp = strchr(lhs,':');
        if (cp == NULL)
            continue;

        // split symbol and value
        *cp = 0;
        rhs = cp + 1;

        // strip trailing whitespace from symbol
        for (cp -= 1;  cp >= lhs;  --cp) {
            if (! XCTWHITE(*cp))
                break;
            *cp = 0;
        }

        // convert "foo bar" into "foo_bar"
        for (cp = lhs;  *cp != 0;  ++cp) {
            if (XCTWHITE(*cp))
                *cp = '_';
        }

        // match on interesting data
        matchflg = 0;
        for (tgb = systvinit_tgb;  TGBMORE(tgb);  ++tgb) {
            if (strcasecmp(lhs,tgb->tgb_tag) == 0) {
                matchflg = tgb->tgb_val;
                break;
            }
        }
        if (! matchflg)
            continue;

        // look for the value
        cp = strtok_r(rhs,dlm,&cur);
        if (cp == NULL)
            continue;

        zprt(ZPXHOWSETUP,"_systvinit: GRAB/%d lhs='%s' cp='%s'\n",
            matchflg,lhs,cp);

        // process the value
        // NOTE: because of Intel's speed step, take the highest cpu speed
        switch (matchflg) {
        case 1:  // genuine CPU speed
            khzcur = _systvinitkhz(cp);
            if (khzcur > khzcpu)
                khzcpu = khzcur;
            break;

        case 2:  // the consolation prize
            khzcur = _systvinitkhz(cp);

            // we've seen some "wild" values
            if (khzcur > 10000000)
                break;

            if (khzcur > khzbogo)
                khzbogo = khzcur;
            break;

        case 3:  // remember # of cpu's so we can adjust bogomips
            mpi->mpi_cpucnt = atoi(cp);
            mpi->mpi_cpucnt += 1;
            break;

        case 4:  // remember # of cpu cores so we can adjust bogomips
            mpi->mpi_corecnt = atoi(cp);
            break;

        case 5:  // cache flush size
            mpi->mpi_cshflush = atoi(cp);
            break;

        case 6:  // cache alignment
            mpi->mpi_cshalign = atoi(cp);
            break;
        }
    }

    fclose(xfsrc);

    // we want to know the number of hyperthreads
    mpi->mpi_smtcnt = mpi->mpi_cpucnt;
    if (mpi->mpi_corecnt)
        mpi->mpi_smtcnt /= mpi->mpi_corecnt;

    zprt(ZPXHOWSETUP,"_systvinit: FINAL khzcpu=%d khzbogo=%d mpi_cpucnt=%d mpi_corecnt=%d mpi_smtcnt=%d mpi_cshalign=%d mpi_cshflush=%d\n",
        khzcpu,khzbogo,mpi->mpi_cpucnt,mpi->mpi_corecnt,mpi->mpi_smtcnt,
        mpi->mpi_cshalign,mpi->mpi_cshflush);

    if ((mpi->mpi_cshalign == 0) || (mpi->mpi_cshflush == 0))
        sysfault("_systvinit: cache parameter fault\n");

    do {
        // use the best reference
        // FIXME/CAE -- with speed step, bogomips is better
#if 0
        if (khzcpu != 0)
            break;
#endif

        khzcpu = khzbogo;
        if (mpi->mpi_smtcnt)
            khzcpu /= mpi->mpi_smtcnt;
        if (khzcpu != 0)
            break;

        sysfault("_systvinit: unable to obtain cpu speed\n");
    } while (0);

    systvkhz(khzcpu);

    zprt(ZPXHOWSETUP,"_systvinit: EXIT\n");
}

// _systvinitkhz -- decode value
// RETURNS: CPU freq in khz
static syskhz_t
_systvinitkhz(char *str)
{
    char *src;
    char *dst;
    int rhscnt;
    char bf[100];
    syskhz_t khz;

    zprt(ZPXHOWSETUP,"_systvinitkhz: ENTER str='%s'\n",str);

    dst = bf;
    src = str;

    // get lhs of lhs.rhs
    for (;  *src != 0;  ++src, ++dst) {
        if (*src == '.')
            break;
        *dst = *src;
    }

    // skip over the dot
    ++src;

    // get rhs of lhs.rhs and determine how many rhs digits we have
    rhscnt = 0;
    for (;  *src != 0;  ++src, ++dst, ++rhscnt)
        *dst = *src;

    *dst = 0;

    khz = atol(bf);
    zprt(ZPXHOWSETUP,"_systvinitkhz: PRESCALE bf='%s' khz=%d rhscnt=%d\n",
        bf,khz,rhscnt);

    // scale down (e.g. we got xxxx.yyyy)
    for (;  rhscnt > 3;  --rhscnt)
        khz /= 10;

    // scale up (e.g. we got xxxx.yy--bogomips does this)
    for (;  rhscnt < 3;  ++rhscnt)
        khz *= 10;

    zprt(ZPXHOWSETUP,"_systvinitkhz: EXIT khz=%d\n",khz);

    return khz;
}

<强>更新

叹息。是。

在引入具有“速度步进”技术的处理器之前，我使用了来自/proc/cpuinfo的“cpu MHz”，所以我切换到“bogomips”，并且算法是根据经验推导出来的。当我得到它时，我只能访问超线程机器。但是，我找到了一个旧的，而SMT的东西无效。

但是，似乎bogomips 总是 [最大] CPU速度的2倍。请参阅http://www.clifton.nl/bogo-faq.html这并不总是我多年来对所有内核版本的体验[IIRC，我从0.99.x开始]，但这些天可能是一个可靠的假设。

在constant_tsc的{{1}}字段中，flags:表示“所有较新的处理器都有”的“常量TSC”，TSC速率是最大CPU频率。

最初，获取频率信息的唯一方法是/proc/cpuinfo。然而，现在，在更现代的内核中，还有另一种可能更容易和更明确的方法[我在我的其他软件中对此进行了代码覆盖，但却忘记了它]：

/proc/cpuinfo

此文件的内容是以kHz为单位的最大CPU频率。其他CPU核心有类似的文件。对于大多数理智的主板，文件应该是相同的（例如，由相同的模型芯片组成的那些并且不试图混合[比较] i7和原子）。否则，您必须在每个核心的基础上跟踪信息，这将很快变得混乱。

给定目录还有其他有趣的文件。例如，如果您的处理器具有“速度步长”[并且其他一些文件可以告诉您]，则可以通过将/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq写入performance文件来强制实现最佳性能。这将禁用速度步骤。

如果处理器不拥有scaling_governor，您必须禁用速度步骤[并以最大速率运行核心]以获得准确的测量结果

Answer 3

BPFtrace

以root身份，您可以使用bpftrace检索内核的TSC速率：

# bpftrace -e 'BEGIN { printf("%u\n", *kaddr("tsc_khz")); exit(); }' | tail -n

（在CentOS 7和Fedora 29上进行了测试）

这是在arch/x86/kernel/tsc.c中定义，导出和维护/校准的值。

GDB

或者，您也可以以root身份从/proc/kcore读取它，例如：

# gdb /dev/null /proc/kcore -ex 'x/uw 0x'$(grep '\<tsc_khz\>' /proc/kallsyms \
    | cut -d' ' -f1) -batch 2>/dev/null | tail -n 1 | cut -f2

（在CentOS 7和Fedora 29上进行了测试）

SystemTap

如果系统没有bpftrace或gdb可用，但有SystemTap，您可以像这样（以root用户身份）获取它：

# cat tsc_khz.stp 
#!/usr/bin/stap -g

function get_tsc_khz() %{ /* pure */
    THIS->__retvalue = tsc_khz;
%}
probe oneshot {
    printf("%u\n", get_tsc_khz());
}
# ./tsc_khz.stp

当然，您还可以编写一个小型内核模块，该模块通过tsc_khz伪文件系统提供对/sys的访问。更好的是，已经有人这样做了，并且tsc_freq_khz module is available on GitHub。这样做应该可以：

# modprobe tsc_freq_khz
$ cat /sys/devices/system/cpu/cpu0/tsc_freq_khz

（在Fedora 29上进行了测试，读取sysfs文件不需要root）

内核消息

如果以上都不是选项，则可以从内核日志中解析TSC速率。但这很快就会变得丑陋，因为您会在不同的硬件和内核上看到不同类型的消息，例如在Fedora 29 i7系统上：

$ journalctl --boot | grep 'kernel: tsc:' -i | cut -d' ' -f5-
kernel: tsc: Detected 2800.000 MHz processor
kernel: tsc: Detected 2808.000 MHz TSC

但是仅在Fedora 29 Intel Atom上：

kernel: tsc: Detected 2200.000 MHz processor

在CentOS 7 i5系统上：

kernel: tsc: Fast TSC calibration using PIT
kernel: tsc: Detected 1895.542 MHz processor
kernel: tsc: Refined TSC clocksource calibration: 1895.614 MHz

性能值

Linux内核尚未提供读取TSC速率的API。但是它确实提供了一个用于获取mult和shift的值，该值可用于将TSC计数转换为纳秒。这些值是从tsc_khz-也在arch/x86/kernel/tsc.c-其中tsc_khz进行初始化和校准得出的。并且它们与用户空间共享。

使用perf API并访问共享页面的示例程序：

#include <asm/unistd.h>
#include <inttypes.h>
#include <linux/perf_event.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>

static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
           int cpu, int group_fd, unsigned long flags)
{
    return syscall(__NR_perf_event_open, hw_event, pid, cpu, group_fd, flags);
}

实际代码：

int main(int argc, char **argv)
{
    struct perf_event_attr pe = {
        .type = PERF_TYPE_HARDWARE,
        .size = sizeof(struct perf_event_attr),
        .config = PERF_COUNT_HW_INSTRUCTIONS,
        .disabled = 1,
        .exclude_kernel = 1,
        .exclude_hv = 1
    };
    int fd = perf_event_open(&pe, 0, -1, -1, 0);
    if (fd == -1) {
        perror("perf_event_open failed");
        return 1;
    }
    void *addr = mmap(NULL, 4*1024, PROT_READ, MAP_SHARED, fd, 0);
    if (!addr) {
        perror("mmap failed");
        return 1;
    }
    struct perf_event_mmap_page *pc = addr;
    if (pc->cap_user_time != 1) {
        fprintf(stderr, "Perf system doesn't support user time\n");
        return 1;
    }
    printf("%16s   %5s\n", "mult", "shift");
    printf("%16" PRIu32 "   %5" PRIu16 "\n", pc->time_mult, pc->time_shift);
    close(fd);
}

在Fedora 29上进行了测试，它也适用于非root用户。

这些值可用于将TSC计数转换为十亿分之一秒，例如：

static uint64_t mul_u64_u32_shr(uint64_t cyc, uint32_t mult, uint32_t shift)
{
    __uint128_t x = cyc;
    x *= mult;
    x >>= shift;
    return x;
}

在x86内核中获得TSC速率

3 个答案:

BPFtrace

GDB

SystemTap

内核消息

性能值