cpi | Tiny c interpreter | Interpreter library

well you can do it , the same method:

on the second thought you can go with this query which is much simpler and does what you want and you don't need to check for RN :

The linear regression fails to define some variables due to singularities.

For a given 10 day subset those variables are constant across all days, thus those variables are perfectly multicollinear and the X'X matrix is singular.

Big Query allows a FROM clause in UPDATE statements...

• https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#update_statement

So, you can write a sub-query which reads from your table and uses LAG() in your CASE expression.

Then, use the UPDATE's WHERE clause to join that result set back on to the target table, using whatever the table's primary key is.

This could be as simple as:

as @deschen proposed, this is the solution:

As Azro said, the problem must be that you are naming your variable with the same name as your function (last_date = last_date(file_path))

Ìn the first iteration of your loop, last_date refer to your function, so last_date() calls your function. When you do last_date = last_date(file_path), last_date does not refer to your function anymore, but instead to your object good_date.

Or, a date object is not callable(it's not a function), that's why you got the TypeError: 'datetime.datetime' object is not callable

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.