msr | A Rust library for industrial automation

Intel Xeon E5-2620 is Sandy Bridge CPU which officially supports AVX and not AVX2.

DPDK 20.11 meson build, ninja -C build will generate code with AVX instructions and not AVX2. But (Based on the live debug) PKTGEN forces the compiler to add AVX2 to be inserted, thus causing illegal instruction.

Solution: edit meson.build in line 22

from

You need to wrap the learner in the GraphLearner PipeOp:

Hi thanks for using mlr3proba! The reason for this is because the parameter names change when wrapped in the pipeline, you can see this in the example below. There are a few options to solve this, you could change the parameter ids to match the new names after wrapping in PipeOps (Option 1 below), or you could specify the tuning ranges for the learner first then wrap it in the PipeOp (Option 2 below), or you could use an AutoTuner and wrap this in the PipeOps. I use the final option in this tutorial.

It looks to me that you may want to use repeated CV to minimize variability introduced by partitioning.

Instead of resampling = rsmp("cv", folds = 20) you could use resampling = rsmp("repeated_cv", folds = 20, repeats = 100) and create 100 different resampling scenarios and benchmark all your learners across these.

This is a common approach in ML to reduce the impact of a single partitioning.

Hi thanks for using mlr3proba. I have actually just finished writing a tutorial that answers exactly this question! It covers training, tuning, and evaluating the neural networks in mlr3proba. For your specific question, the relevant part of the tutorial is this:

I have doubts if this is a statistically sound approach, but technically you can set the aggregating function for a measure by overwriting the aggregator slot:

Support of RKL in the intel_rapl driver was added in v5.9-rc5 and the core and uncore perf events were added in v5.11-rc1. Are you sure you have v5.12-rc6? What does uname -a print? Ubuntu 20.10 is based on v5.8 + other backported patches (one of which provides support for all the of uncore_imc events available on modern Intel client processors).

The perf_event subsystem lets you only use the architectural events if it's running on an unsupported processor model. But you can still use the raw event encoding as documented in the perf man pages. This approach is only reliable for events without constraints because perf_event isn't aware of any constraints that may exist on an unsupported model. Most events don't have constraints, so this isn't a major problem.

I don't know why you think that rapl-read can't be used to profile a program. There is no program-specific or core-specific RAPL domains. You can run rapl-read with the -m option to directly access MSRs to take energy readings, then your program, then run rapl-read again. The difference between the two readings gives you energy consumption for each of the supported domains. Note that you've to modify the rapl_msr() function so that it invokes your program between the readings instead of just doing sleep(1). Otherwise, it'll just report the energy consumption in about a second with hardly any correlation of the energy consumption of your program.

rapl-read doesn't currently support RKL (or any of the very recent Intel processors). But you can easily add RAPL support by first determining the CPU model from cat /proc/cpuinfo and then adding a macro definition like #define CPU_ROCKETLAKE model similar to the currently supported models. I see only two switch statements on the CPU mode, one in detect_cpu(void) and one in rapl_msr(int core, int cpu_model). Just add a case for CPU_ROCKETLAKE. RKL has the same RAPL domains as SKL, so place together with CPU_SKYLAKE in both functions. That should do it. Or you can avoid rapl-read altogether and just use wrmsr and rdmsr in a shell script that takes readings, runs the program, and then takes readings again.

MSR 0x611 is MSR_PKG_ENERGY_STATUS, which reports a 32-bit unsigned value. The unit of this value is MSR_RAPL_POWER_UNIT and the default is 15.26uj. You seem to think it's in micro-joules. Are you sure that this is what MSR_RAPL_POWER_UNIT says? Even then, the result of the expression $(((end_energy - bgn_energy)/ujtoj))e-3 is in kilo-joules, so how are you comparing it with power/energy_pkg on Zen3, which is clearly in joules?

If the correct unit is 15.26uj, then the measurement on the Intel processor would be 15.26*197000000 = 3,009,226,220,000 joules (about 3000 gigajoules). But since only the lowest 32 bits of the MSR register are valid, the maximum value is 15.26*(2^32 - 1) = 65,541,200,921.7 joules (about 65 gigajoules). So I think the unit is not 15.26uj.

It seems that the 500.perlbench benchmark with the test input took about 3 minutes to complete. It's hard to know whether MSR_PKG_ENERGY_STATUS has wrapped around or not because the reported number is not negative.

I think it's better to run 500.perlbench on one core and then run a script on another core that reads MSR_PKG_ENERGY_STATUS every few seconds. For example, you can put rdmsr -d 0x611 in a loop and sleep for some number of seconds in each iteration. Since 500.perlbench takes a relatively long time to complete, you don't have to start both programs at precisely the same time. In this way, you'd mimic the way perf stat -a -I 1000 -e power/energy-pkg/ works had the event power/energy-pkg/ been supported on your kernel on the Intel platform.

I've discussed the reliability of Intel's RAPL-based energy measurements at: perf power consumption measure: How does it work?. However, I don't know if anyone has validated the accuracy of AMD's RAPL. It's unclear to me to what extent a comparison between Intel's MSR_PKG_ENERGY_STATUS and AMD's Core::X86::Msr::PKG_ENERGY_STAT is meaningful.

So the error was as follows:

A GraphLearner always wraps a Graph that takes a single Task as input and produces a single Prediction as output. A Graph can, however, represent any kind of computation and can even take multiple inputs / produce multiple outputs. You would often use these as intermediate building blocks when building a Graph that does training on a single task, giving a single prediction, which is then wrapped as a GraphLearner.

In some cases this could also be helpful if you do some kind of preprocessing such as imputation or PCA that should also be applied to some kind of unseen data (i.e. apply the same rotation as PCA), even though your process as a whole is not classical machine learning producing a model for predictions: