Developing...

Author: JustPlay

msrtool/Makefile

@@ -0,0 +1,31 @@
+#
+# Makefile for MSRs
+#
+
+CC       = g++ 
+CFLAGS   =-std=c++11 -Wall -g -O2 -fomit-frame-pointer -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64
+LDFLAGS  = 
+
+BIN	= msr_write  msr_read
+
+sbindir = /usr/sbin
+
+all: $(BIN)
+
+clean:
+	rm -f *.o $(BIN)
+
+distclean: clean
+	rm -f *~ \#*
+
+install: all
+	install -m 755 $(BIN) $(sbindir)
+
+.o:
+	$(CC) $(LDFLAGS) -o $@ $<
+
+.c.o:
+	$(CC) $(CFLAGS) -o $@ $<
+
+.c:
+	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<

msrtool/README

@@ -0,0 +1,37 @@
+
+Fixing uncore frequency
+    Uncore frequency can be set by writing the same value for both minimum and maximum 
+    frequency through MSR 0x620 on each socket.
+    
+    In MSR 0x620, bits 0-7 indicate the maximum frequency (in units of 100Mhz),
+    while bits 8-15 capture the minimum frequency. 
+
+    For example, if you want to set the uncore frequency to 2700 MHz,
+    you need to write the value 27 (0x1b in hex) for both max and min frequency.
+    So, 0x1b1b would be written to MSR 0x620. 
+
+    ./wrmsr  -a   0x620 0x1b1b 
+    ./wrmsr  -p0  0x620 0x1b1b 
+
+Set LLC cache ways
+    Cache size is controlled by reducing the number of ways in each set.
+    By default, we have 20 ways in each cache set.
+    The following recipe is used to cut the # of ways down thus reducing the available total cache size.
+
+
+    ./rdmsr -a 0xc8f
+    ./rdmsr -a 0xc90
+
+    将Cache的默认20Way(0xfffff, 20bits setted)修改为15Way(0x7fff, 15bits setted)
+    ./wrmsr -a 0xc8f 0           1. Write 0 to msr 0xc8f on all cores
+    ./wrmsr -a 0xc90 0x7fff      2. Write <X> to msr 0xc90 on all the cores
+
+     a. The default value for <X> is 0xfffff (one bit set for each of the 20 ways of the set).
+        By setting this value lower, you can disable cache ways and reduce the size.
+        For example to reduce the cache size to 1/4 the size, the # of ways should be cut from 20 to 5. 
+        That would be writing 0x1F to msr 0xc90.
+     b. The above write should be done only once and if additional sizes are needed, a reboot is recommended 
+        (where in you will set the new value after the reboot)
+     c. Note that <X> value should have contiguous bits set i.e 0xFF is ok while 0xF0F is not ok
+
+

msrtool/msr_read.cpp

@@ -0,0 +1,243 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cctype>
+
+#include <vector>
+#include <string>
+
+#include <inttypes.h>
+#include <sys/types.h>
+
+#include <unistd.h>
+#include <dirent.h>
+#include <getopt.h>
+#include <libgen.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <err.h>
+
+#include "msr_version.hpp"
+
+#define program "msr_read"
+
+#define msr_warn(fmt, ...) fprintf(stderr, program ": " fmt, ##__VA_ARGS__) 
+
+namespace msr {
+    
+const struct option long_options[] = {
+    {"help",      no_argument,       NULL, 'h'},
+    {"version",   no_argument,       NULL, 'V'},
+    {"all",       no_argument,       NULL, 'a'},
+    {"processor", required_argument, NULL, 'p'},
+    {"cpu",       required_argument, NULL, 'p'},
+    {NULL,        no_argument,       NULL,  0 }
+};
+
+const char shot_options[] = "hVap:";
+
+typedef struct {
+    int cpu;
+    uint32_t reg;
+} options_t;
+
+options_t options;
+
+
+void usage()
+{
+    fprintf(stderr,
+            "Usage:\n"
+            "    %s [options] <register-id> <register-value> [...]\n"
+            "Options:\n"
+            "    --help         -h  print this help\n"
+            "    --version      -V  print current version\n"
+            "    --all          -a  all processors\n"
+            "    --processor #  -p  select processor number (default 0)\n",
+            program
+        );
+}
+
+void version()
+{
+    fprintf(stderr, "%s: version %s\n", program, MSR_VERSION_STRING);
+}
+
+int is_cpu(const struct dirent *dirp)
+{
+    return std::isdigit(dirp->d_name[0]); /* /dev/cpu/<cpu> */
+}
+
+bool is_onln(int cpu)
+{
+    if (cpu < 0) {
+        return false;
+    }
+
+    // the boot cpu do *not* support hotplug (x86 platform, linux-2.6.x, linux-4.7.x)
+    if (cpu == 0) {
+        return true;
+    }
+
+    // if online, the cache directory exist, otherwise not (x86 platform, linux-2.6.x, linux-4.7.x)
+    std::string cpu_path = "/sys/devices/system/cpu/cpu" + std::to_string(cpu) + "/cache"; 
+
+    if (::access(cpu_path.c_str(), F_OK) != 0) {
+        return false;
+    }
+
+    return true;
+}
+
+/**
+ * msr_print - print value in the given format
+ *
+ * @val  value to print
+ *
+ * FIXME:
+ *
+ */
+void msr_print(uint64_t val)
+{
+    FILE *fp = stdout;
+
+    fprintf(fp, "%zx\n", val);
+}
+
+/** 
+ * msr_read - read values from @cpu's msr register specified by @reg
+ *
+ * @cpu   which processor
+ * @reg   the register id
+ *
+ * Return:
+ *     true  - read succ
+ *     false - read fail
+ */
+bool msr_read(int cpu, uint32_t reg)
+{
+    if (!is_onln(cpu)) {
+        msr_warn("cpu %2d does not online\n", cpu);
+        return true;
+    }
+
+    std::string msr_path = "/dev/cpu/" + std::to_string(cpu) + "/msr";  
+
+    int fd = ::open(msr_path.c_str(), O_RDONLY);
+    if (fd == -1) {
+        switch(errno) {
+
+        // the file is a device special file and no corresponding device exists
+        case ENXIO:
+            msr_warn("cpu %2d does not exist\n", cpu);
+            return false; 
+
+        //
+        case EIO:
+            msr_warn("cpu %2d does not support MSR\n", cpu);
+            return false; 
+
+        default:
+            msr_warn("failed on open MSR file for cpu %d, %s\n", cpu, strerror_r(errno, NULL, 0));
+            return false; 
+        }
+    }
+    
+    uint64_t val = 0;
+
+    if (::pread(fd, &val, sizeof(val), reg) != sizeof(val)) {
+        msr_warn("failed to read MSR file for cpu %d, %s\n", cpu, strerror_r(errno, NULL, 0)); 
+        ::close(fd);
+        return false;
+    }
+   
+    ::close(fd);
+
+    msr_print(val);
+
+    return true;
+}
+
+
+/** 
+ * msr_read - read values from all (online) cpus' msr register specified by @reg
+ *
+ * @reg   the register id
+ *
+ * Return:
+ *     true  - read succ
+ *     false - read fail
+ */
+bool msr_read(uint32_t reg)
+{
+    struct dirent **namelist; 
+    size_t nr_dirent = 0;
+
+    nr_dirent = ::scandir("/dev/cpu", &namelist, is_cpu, 0);
+
+    for (size_t cpu = 0; cpu < nr_dirent; ++cpu) {
+        msr_read(std::stoi(namelist[cpu]->d_name), reg);
+    }
+
+    for (size_t cpu = 0; cpu < nr_dirent; ++cpu) {
+        free(namelist[cpu]);
+    }
+
+    free(namelist);
+
+    return true;
+}
+
+} /* namespace msr */
+
+
+int main(int argc, char **argv)
+{
+    char ch;
+    while ((ch = getopt_long(argc, argv, msr::shot_options, msr::long_options, NULL)) != -1) {
+        switch (ch) {
+        case 'h':
+            msr::usage();
+            exit(EXIT_SUCCESS);
+
+        case 'V':
+            msr::version();
+            exit(EXIT_SUCCESS);
+
+        case 'a':
+            msr::options.cpu = -1;  
+            break;
+
+        case 'p':
+            msr::options.cpu = std::stoi(optarg);
+            break;
+            
+        default:
+            msr::usage();
+            exit(EXIT_FAILURE);
+        }        
+    }
+
+    if (optind + 1 > argc) {
+        msr::usage();
+        exit(EXIT_FAILURE);
+    }
+
+    if (geteuid() != 0) {
+        msr_warn("you need root privilege to run\n");
+        exit(EXIT_FAILURE);
+    }
+
+    msr::options.reg = std::stoul(argv[optind++], 0, 16);
+
+    if (msr::options.cpu == -1) {
+        msr::msr_read(msr::options.reg);
+    } else {
+        msr::msr_read(msr::options.cpu, msr::options.reg);
+    }
+}

msrtool/msr_version.hpp

@@ -0,0 +1,6 @@
+#ifndef __MSR_VERSION_HPP__
+#define __MSR_VERSION_HPP__
+
+#define MSR_VERSION_STRING "developing"
+
+#endif /* __MSR_VERSION_HPP__ */