diff for duplicates of <20150831041607.GA15543@hr-slim.amd.com> diff --git a/a/1.txt b/N1/1.txt index 12c6216..f48ca10 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,100 +1,143 @@ -T24gRnJpLCBBdWcgMjgsIDIwMTUgYXQgMDc6MDU6MTNBTSAtMDcwMCwgR3VlbnRlciBSb2VjayB3 -cm90ZToKPiBPbiAwOC8yOC8yMDE1IDAzOjQ1IEFNLCBIdWFuZyBSdWkgd3JvdGU6Cj4gPk9uIFRo -dSwgQXVnIDI3LCAyMDE1IGF0IDEwOjMwOjQzQU0gLTA3MDAsIEd1ZW50ZXIgUm9lY2sgd3JvdGU6 -Cj4gPj5PbiBUaHUsIEF1ZyAyNywgMjAxNSBhdCAwNDowNzo0M1BNICswODAwLCBIdWFuZyBSdWkg -d3JvdGU6Cj4gPj4+VGhpcyBwYXRjaCBpbnRyb2R1Y2VzIGFuIGFsZ29yaXRobSB0aGF0IGNvbXB1 -dGVzIHRoZSBhdmVyYWdlIHBvd2VyIGJ5Cj4gPj4+cmVhZGluZyBhIGRlbHRhIHZhbHVlIG9mIOKA -nGNvcmUgcG93ZXIgYWNjdW11bGF0b3LigJ0gcmVnaXN0ZXIgZHVyaW5nCj4gPj4+bWVhc3VyZW1l -bnQgaW50ZXJ2YWwsIGFuZCB0aGVuIGRpdmlkaW5nIGRlbHRhIHZhbHVlIGJ5IHRoZSBsZW5ndGgg -b2YKPiA+Pj50aGUgdGltZSBpbnRlcnZhbC4KPiA+Pj4KPiA+Pj5Vc2VyIGlzIGFibGUgdG8gdXNl -IHBvd2VyMV9hY2MgZW50cnkgdG8gbWVhc3VyZSB0aGUgcHJvY2Vzc29yIHBvd2VyCj4gPj4+Y29u -c3VtcHRpb24gYW5kIHBvd2VyMV9hY2MganVzdCBuZWVkcyB0byBiZSByZWFkIHR3aWNlIHdpdGgg -YW4gbmVlZGVkCj4gPj4+aW50ZXJ2YWwgaW4tYmV0d2Vlbi4KPiA+Pj4KPiA+Pj5BIHNpbXBsZSBl -eGFtcGxlOgo+ID4+Pgo+ID4+PiQgY2F0IC9zeXMvYnVzL3BjaS9kZXZpY2VzLzAwMDBcOjAwXDox -OC40L2h3bW9uL2h3bW9uMC9wb3dlcjFfYWNjCj4gPj4+JCBzbGVlcCAxMDAwMHMKPiA+Pj4kIGNh -dCAvc3lzL2J1cy9wY2kvZGV2aWNlcy8wMDAwXDowMFw6MTguNC9od21vbi9od21vbjAvcG93ZXIx -X2FjYwo+ID4+Pgo+ID4+PlRoZSByZXN1bHQgaXMgY3VycmVudCBhdmVyYWdlIHByb2Nlc3NvciBw -b3dlciBjb25zdW1wdGlvbiBpbiAxMDAwMAo+ID4+PnNlY29uZHMuIFRoZSB1bml0IG9mIHRoZSBy -ZXN1bHQgaXMgdVdhdHQuCj4gPj4+Cj4gPj4+U2lnbmVkLW9mZi1ieTogSHVhbmcgUnVpIDxyYXku -aHVhbmdAYW1kLmNvbT4KPiA+Pj4tLS0KPiA+Pj4gIGRyaXZlcnMvaHdtb24vZmFtMTVoX3Bvd2Vy -LmMgfCA2MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ID4+ -PiAgMSBmaWxlIGNoYW5nZWQsIDYyIGluc2VydGlvbnMoKykKPiA+Pj4KPiA+Pj5kaWZmIC0tZ2l0 -IGEvZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYyBiL2RyaXZlcnMvaHdtb24vZmFtMTVoX3Bv -d2VyLmMKPiA+Pj5pbmRleCBkNTI5ZTRiLi4zYmFiNzk3IDEwMDY0NAo+ID4+Pi0tLSBhL2RyaXZl -cnMvaHdtb24vZmFtMTVoX3Bvd2VyLmMKPiA+Pj4rKysgYi9kcml2ZXJzL2h3bW9uL2ZhbTE1aF9w -b3dlci5jCj4gPj4+QEAgLTYwLDYgKzYwLDcgQEAgc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhIHsK -PiA+Pj4gIAl1NjQgY3VfYWNjX3Bvd2VyW01BWF9DVVNdOwo+ID4+PiAgCS8qIHBlcmZvcm1hbmNl -IHRpbWVzdGFtcCBjb3VudGVyICovCj4gPj4+ICAJdTY0IGNwdV9zd19wd3JfcHRzY1tNQVhfQ1VT -XTsKPiA+Pj4rCXN0cnVjdCBtdXRleCBhY2NfcHdyX211dGV4Owo+ID4+PiAgfTsKPiA+Pj4KPiA+ -Pj4gIHN0YXRpYyBzc2l6ZV90IHNob3dfcG93ZXIoc3RydWN0IGRldmljZSAqZGV2LAo+ID4+PkBA -IC0xMjEsMTcgKzEyMiw3NCBAQCBzdGF0aWMgREVWSUNFX0FUVFIocG93ZXIxX2NyaXQsIFNfSVJV -R08sIHNob3dfcG93ZXJfY3JpdCwgTlVMTCk7Cj4gPj4+ICBzdGF0aWMgc3RydWN0IGF0dHJpYnV0 -ZV9ncm91cCBmYW0xNWhfcG93ZXJfZ3JvdXA7Cj4gPj4+ICBfX0FUVFJJQlVURV9HUk9VUFMoZmFt -MTVoX3Bvd2VyKTsKPiA+Pj4KPiA+Pj4rc3RhdGljIHNzaXplX3Qgc2hvd19wb3dlcl9hY2Moc3Ry -dWN0IGRldmljZSAqZGV2LAo+ID4+PisJCQkgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq -YXR0ciwgY2hhciAqYnVmKQo+ID4+Pit7Cj4gPj4+KwlpbnQgY3B1LCBjdSwgY3VfbnVtLCBjb3Jl -c19wZXJfY3U7Cj4gPj4+Kwl1NjQgY3Vycl9jdV9hY2NfcG93ZXJbTUFYX0NVU10sCj4gPj4+Kwkg -ICAgY3Vycl9wdHNjW01BWF9DVVNdLCBqZGVsdGFbTUFYX0NVU107Cj4gPj4+Kwl1NjQgdGRlbHRh -LCBhdmdfYWNjOwo+ID4+PisJc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhICpkYXRhID0gZGV2X2dl -dF9kcnZkYXRhKGRldik7Cj4gPj4+Kwo+ID4+PisJY29yZXNfcGVyX2N1ID0gYW1kX2dldF9jb3Jl -c19wZXJfY3UoKTsKPiA+Pj4rCWN1X251bSA9IGJvb3RfY3B1X2RhdGEueDg2X21heF9jb3JlcyAv -IGNvcmVzX3Blcl9jdTsKPiA+Pj4rCj4gPj4+Kwlmb3IgKGNwdSA9IDAsIGF2Z19hY2MgPSAwOyBj -cHUgPCBjdV9udW0gKiBjb3Jlc19wZXJfY3U7IGNwdSArPSBjb3Jlc19wZXJfY3UpIHsKPiA+Pj4r -CQljdSA9IGNwdSAvIGNvcmVzX3Blcl9jdTsKPiA+Pj4rCQlpZiAocmRtc3JsX3NhZmVfb25fY3B1 -KGNwdSwgTVNSX0YxNUhfUFRTQywgJmN1cnJfcHRzY1tjdV0pKSB7Cj4gPj4+KwkJCXByX2Vycigi -RmFpbGVkIHRvIHJlYWQgUFRTQyBjb3VudGVyIE1TUiBvbiBjb3JlJWRcbiIsCj4gPj4+KwkJCSAg -ICAgICBjcHUpOwo+ID4+PisJCQlyZXR1cm4gMDsKPiA+Pj4rCQl9Cj4gPj4+Kwo+ID4+PisJCWlm -IChyZG1zcmxfc2FmZV9vbl9jcHUoY3B1LCBNU1JfRjE1SF9DVV9QV1JfQUNDVU1VTEFUT1IsCj4g -Pj4+KwkJCQkgICAgICAgJmN1cnJfY3VfYWNjX3Bvd2VyW2N1XSkpIHsKPiA+Pj4rCQkJcHJfZXJy -KCJGYWlsZWQgdG8gcmVhZCBjb21wdXRlIHVuaXQgcG93ZXIgYWNjdW11bGF0b3IgTVNSIG9uIGNv -cmUlZFxuIiwKPiA+Pj4rCQkJICAgICAgIGNwdSk7Cj4gPj4+KwkJCXJldHVybiAwOwo+ID4+PisJ -CX0KPiA+Pj4rCj4gPj4+KwkJaWYgKGN1cnJfY3VfYWNjX3Bvd2VyW2N1XSA8IGRhdGEtPmN1X2Fj -Y19wb3dlcltjdV0pIHsKPiA+Pj4rCQkJamRlbHRhW2N1XSA9IGRhdGEtPm1heF9jdV9hY2NfcG93 -ZXIgKyBjdXJyX2N1X2FjY19wb3dlcltjdV07Cj4gPj4+KwkJCWpkZWx0YVtjdV0gLT0gZGF0YS0+ -Y3VfYWNjX3Bvd2VyW2N1XTsKPiA+Pj4rCQl9IGVsc2Ugewo+ID4+PisJCQlqZGVsdGFbY3VdID0g -Y3Vycl9jdV9hY2NfcG93ZXJbY3VdIC0gZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XTsKPiA+Pj4rCQl9 -Cj4gPj4+KwkJdGRlbHRhID0gY3Vycl9wdHNjW2N1XSAtIGRhdGEtPmNwdV9zd19wd3JfcHRzY1tj -dV07Cj4gPj4+KwkJamRlbHRhW2N1XSAqPSBkYXRhLT5jcHVfcHdyX3NhbXBsZV9yYXRpbyAqIDEw -MDA7Cj4gPj4+KwkJZG9fZGl2KGpkZWx0YVtjdV0sIHRkZWx0YSk7Cj4gPj4+Kwo+ID4+PisJCW11 -dGV4X2xvY2soJmRhdGEtPmFjY19wd3JfbXV0ZXgpOwo+ID4+PisJCWRhdGEtPmN1X2FjY19wb3dl -cltjdV0gPSBjdXJyX2N1X2FjY19wb3dlcltjdV07Cj4gPj4+KwkJZGF0YS0+Y3B1X3N3X3B3cl9w -dHNjW2N1XSA9IGN1cnJfcHRzY1tjdV07Cj4gPj4+KwkJbXV0ZXhfdW5sb2NrKCZkYXRhLT5hY2Nf -cHdyX211dGV4KTsKPiA+Pj4rCj4gPj4+KwkJLyogdGhlIHVuaXQgaXMgbWljcm9XYXR0ICovCj4g -Pj4+KwkJYXZnX2FjYyArPSBqZGVsdGFbY3VdOwo+ID4+PisJfQo+ID4+PisKPiA+Pj4rCXJldHVy -biBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCAodW5zaWduZWQgaW50KSBhdmdfYWNjKTsKPiA+Pj4rfQo+ -ID4+PitzdGF0aWMgREVWSUNFX0FUVFIocG93ZXIxX2FjYywgU19JUlVHTywgc2hvd19wb3dlcl9h -Y2MsIE5VTEwpOwo+ID4+Cj4gPj5JIGFtIG5vdCByZWFsbHkgYSBmcmllbmQgb2YgaW50cm9kdWNp -bmcgYSBub24tc3RhbmRhcmQgYXR0cmlidXRlLgo+ID4+RG9lcyB0aGUgZW5lcmd5IGF0dHJpYnV0 -ZSBub3Qgd29yayBoZXJlID8KPiA+Pgo+ID4KPiA+WW91J3JlIHJpZ2h0LiBOb24tc3RhbmRhcmQg -YXR0cmlidXRlIG1pZ2h0IG5vdCBiZSBnb29kLiBDb3VsZCB5b3UKPiA+cGxlYXNlIGdpdmUgbWUg -c29tZSBoaW50cyBpZiBJIHVzZSAiZW5lcmd5IiBpbnN0ZWFkPwo+ID4KPiAxIEpvdWxlID0gMSBX -YXR0LXNlY29uZC4KPiAKPiBTb21ldGhpbmcgZWxzZSwgdGhvdWdoIC0gZGlkIHlvdSBtYWtlIHN1 -cmUgdGhhdCB5b3VyIGNvZGUgZG9lc24ndCBvdmVyZmxvdyA/Cj4gRXZlbiB0aG91Z2ggeW91IGNh -bGN1bGF0ZSB0aGUgYXZlcmFnZSBpbiBhbiB1NjQsIHlvdSBkaXNwbGF5IGl0IGFzIHVuc2lnbmVk -Lgo+IAoKVGhhbmtzIHRvIHlvdXIgcmVtaW5kZXIuIEl0IHNob3VsZCBub3QgYmUgb3ZlcmZsb3cu -IFRoZSBtYXhpbXVtIHBvd2VyCmNvbnN1bXB0aW9uIG9mIHByb2Nlc3NvciAoQU1EIENaIGFuZCBm -dXR1cmUgMTVoKSBpcyBhYm91dCAxNSBXYXR0cyA9CjE1LDAwMCwwMDAgdVdhdHRzID0gMHhFNEUx -QzAgdVdhdHRzLCB0aGUgc2l6ZSBpcyAyNCA8IDMyIDwgNjQgYml0cy4KCkFjdHVhbGx5LCB0aGUg -dW5pdCBvZiBqZGVsdGEgaXMgbm90IEpvdWxlLiBCZWNhdXNlIHRoZSB0ZGVsdGEgaXMgdGhlCmxv -b3BzIChjeWNsZXMpIHRoYXQgUFRTQyBjb3VudGVyICh0aGUgZnJlcWVuY3kgaXMgYWJvdXQgMTAw -IE1IeikKY291bnRzIG5vdCBzZWNvbmRzLgoKU28gYXZnX2FjYyBpcyB0aGUgYXZlcmFnZSBwb3dl -ciBjb25zdW1wdGlvbiBub3QgdGhlIGFjY3VtdWxhdGVkIGVuZXJneS4KCj4gMTAwdyAqIDEwLDAw -MHMgPSAxLDAwMCwwMDB3cyA9IDEsMDAwLDAwMCwwMDAsMDAwIG1pY3JvLXdhdHQtc2Vjb25kcywg -d2hpY2ggaXMKPiBhIGJpdCBsYXJnZSBmb3IgYW4gdW5zaWduZWQuCj4gCj4gQWxzbywgdGhlIHZh -bHVlcyBzaG91bGQgbm90IGJlIHJlc2V0IGFmdGVyIHJlYWRpbmcsIGJ1dCBhY2N1bXVsYXRlLgo+ -IAo+IEFsc28sIEkgdGhpbmsgeW91ciBjb2RlIG1heSBiZSB2dWxuZXJhYmxlIHRvIG92ZXJmbG93 -cyBvbiB0aGUgQ1BVIHJlZ2lzdGVyIHNpZGUuCj4gSG93IGxvbmcgZG9lcyBpdCB0YWtlIGJlZm9y -ZSB0aGUgQ1BVIGNvdW50ZXJzIG92ZXJmbG93ID8KPiAKCklmIEkgdXNlICJlbmVyZ3kiLCAxNXcg -KiAxMCwwMDBzID0gMTUwLDAwMCwwMDAsMDAwIG1pY3JvV2F0dC1zZWNvbmRzLgpZZXMsIGl0J3Mg -bGFyZ2UgZm9yIGFuIHVuc2lnbmVkLCBidXQgc3VpdGFibGUgZm9yIHU2NC4KClRoZSBhY2N1bXVs -YXRlZCBwb3dlciBvZiBvbmUgY29tcHV0ZSB1bml0IGlzIHJlY29yZGVkIGF0IDY0Yml0IE1TUi4K -CkxldCBtZSBjYWxjdWxhdGUgdGhlIGV4dHJlbWUgY2FzZSB0aGF0IGhvdyBsb25nIGRvZXMgaXQg -dGFrZSBiZWZvcmUKb3ZlcmZsb3c6CgpVc2UgcG93ZXIgY29uc3VtcHRpb24gMTV3LCBtYXggcG93 -ZXIgMl42NCA9IDEuOCAqIDEwXjE5Cm1XYXR0LXB0c2NfbG9vcHMsIGFuZCBQVFNDIGZyZXFlbmN5 -IDEwMCBNSHo6CgogICAgICAgIDEuOCAqIDEwXjE5ID0gKDE1LDAwMCkgKiAoVG1heC9UY3ljbGUp -CiAgICAgICAgMS44ICogMTBeMTkgPSAoMTUsMDAwKSAqIChUbWF4ICogUFRTQ19GcmVxKQogICAg -ICAgIDEuOCAqIDEwXjE5ID0gKDE1LDAwMCkgKiAoVG1heCAqIDEwMCwwMDAsMDAwKQogICAgICAg -IFRtYXggPSAxLjIgKiAxMF43IHNlY29uZHMKClRoYW5rcwpSdWkKCl9fX19fX19fX19fX19fX19f -X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0Cmxt -LXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxt -YW4vbGlzdGluZm8vbG0tc2Vuc29ycw= +On Fri, Aug 28, 2015 at 07:05:13AM -0700, Guenter Roeck wrote: +> On 08/28/2015 03:45 AM, Huang Rui wrote: +> >On Thu, Aug 27, 2015 at 10:30:43AM -0700, Guenter Roeck wrote: +> >>On Thu, Aug 27, 2015 at 04:07:43PM +0800, Huang Rui wrote: +> >>>This patch introduces an algorithm that computes the average power by +> >>>reading a delta value of “core power accumulator” register during +> >>>measurement interval, and then dividing delta value by the length of +> >>>the time interval. +> >>> +> >>>User is able to use power1_acc entry to measure the processor power +> >>>consumption and power1_acc just needs to be read twice with an needed +> >>>interval in-between. +> >>> +> >>>A simple example: +> >>> +> >>>$ cat /sys/bus/pci/devices/0000\:00\:18.4/hwmon/hwmon0/power1_acc +> >>>$ sleep 10000s +> >>>$ cat /sys/bus/pci/devices/0000\:00\:18.4/hwmon/hwmon0/power1_acc +> >>> +> >>>The result is current average processor power consumption in 10000 +> >>>seconds. The unit of the result is uWatt. +> >>> +> >>>Signed-off-by: Huang Rui <ray.huang@amd.com> +> >>>--- +> >>> drivers/hwmon/fam15h_power.c | 62 ++++++++++++++++++++++++++++++++++++++++++++ +> >>> 1 file changed, 62 insertions(+) +> >>> +> >>>diff --git a/drivers/hwmon/fam15h_power.c b/drivers/hwmon/fam15h_power.c +> >>>index d529e4b..3bab797 100644 +> >>>--- a/drivers/hwmon/fam15h_power.c +> >>>+++ b/drivers/hwmon/fam15h_power.c +> >>>@@ -60,6 +60,7 @@ struct fam15h_power_data { +> >>> u64 cu_acc_power[MAX_CUS]; +> >>> /* performance timestamp counter */ +> >>> u64 cpu_sw_pwr_ptsc[MAX_CUS]; +> >>>+ struct mutex acc_pwr_mutex; +> >>> }; +> >>> +> >>> static ssize_t show_power(struct device *dev, +> >>>@@ -121,17 +122,74 @@ static DEVICE_ATTR(power1_crit, S_IRUGO, show_power_crit, NULL); +> >>> static struct attribute_group fam15h_power_group; +> >>> __ATTRIBUTE_GROUPS(fam15h_power); +> >>> +> >>>+static ssize_t show_power_acc(struct device *dev, +> >>>+ struct device_attribute *attr, char *buf) +> >>>+{ +> >>>+ int cpu, cu, cu_num, cores_per_cu; +> >>>+ u64 curr_cu_acc_power[MAX_CUS], +> >>>+ curr_ptsc[MAX_CUS], jdelta[MAX_CUS]; +> >>>+ u64 tdelta, avg_acc; +> >>>+ struct fam15h_power_data *data = dev_get_drvdata(dev); +> >>>+ +> >>>+ cores_per_cu = amd_get_cores_per_cu(); +> >>>+ cu_num = boot_cpu_data.x86_max_cores / cores_per_cu; +> >>>+ +> >>>+ for (cpu = 0, avg_acc = 0; cpu < cu_num * cores_per_cu; cpu += cores_per_cu) { +> >>>+ cu = cpu / cores_per_cu; +> >>>+ if (rdmsrl_safe_on_cpu(cpu, MSR_F15H_PTSC, &curr_ptsc[cu])) { +> >>>+ pr_err("Failed to read PTSC counter MSR on core%d\n", +> >>>+ cpu); +> >>>+ return 0; +> >>>+ } +> >>>+ +> >>>+ if (rdmsrl_safe_on_cpu(cpu, MSR_F15H_CU_PWR_ACCUMULATOR, +> >>>+ &curr_cu_acc_power[cu])) { +> >>>+ pr_err("Failed to read compute unit power accumulator MSR on core%d\n", +> >>>+ cpu); +> >>>+ return 0; +> >>>+ } +> >>>+ +> >>>+ if (curr_cu_acc_power[cu] < data->cu_acc_power[cu]) { +> >>>+ jdelta[cu] = data->max_cu_acc_power + curr_cu_acc_power[cu]; +> >>>+ jdelta[cu] -= data->cu_acc_power[cu]; +> >>>+ } else { +> >>>+ jdelta[cu] = curr_cu_acc_power[cu] - data->cu_acc_power[cu]; +> >>>+ } +> >>>+ tdelta = curr_ptsc[cu] - data->cpu_sw_pwr_ptsc[cu]; +> >>>+ jdelta[cu] *= data->cpu_pwr_sample_ratio * 1000; +> >>>+ do_div(jdelta[cu], tdelta); +> >>>+ +> >>>+ mutex_lock(&data->acc_pwr_mutex); +> >>>+ data->cu_acc_power[cu] = curr_cu_acc_power[cu]; +> >>>+ data->cpu_sw_pwr_ptsc[cu] = curr_ptsc[cu]; +> >>>+ mutex_unlock(&data->acc_pwr_mutex); +> >>>+ +> >>>+ /* the unit is microWatt */ +> >>>+ avg_acc += jdelta[cu]; +> >>>+ } +> >>>+ +> >>>+ return sprintf(buf, "%u\n", (unsigned int) avg_acc); +> >>>+} +> >>>+static DEVICE_ATTR(power1_acc, S_IRUGO, show_power_acc, NULL); +> >> +> >>I am not really a friend of introducing a non-standard attribute. +> >>Does the energy attribute not work here ? +> >> +> > +> >You're right. Non-standard attribute might not be good. Could you +> >please give me some hints if I use "energy" instead? +> > +> 1 Joule = 1 Watt-second. +> +> Something else, though - did you make sure that your code doesn't overflow ? +> Even though you calculate the average in an u64, you display it as unsigned. +> + +Thanks to your reminder. It should not be overflow. The maximum power +consumption of processor (AMD CZ and future 15h) is about 15 Watts = +15,000,000 uWatts = 0xE4E1C0 uWatts, the size is 24 < 32 < 64 bits. + +Actually, the unit of jdelta is not Joule. Because the tdelta is the +loops (cycles) that PTSC counter (the freqency is about 100 MHz) +counts not seconds. + +So avg_acc is the average power consumption not the accumulated energy. + +> 100w * 10,000s = 1,000,000ws = 1,000,000,000,000 micro-watt-seconds, which is +> a bit large for an unsigned. +> +> Also, the values should not be reset after reading, but accumulate. +> +> Also, I think your code may be vulnerable to overflows on the CPU register side. +> How long does it take before the CPU counters overflow ? +> + +If I use "energy", 15w * 10,000s = 150,000,000,000 microWatt-seconds. +Yes, it's large for an unsigned, but suitable for u64. + +The accumulated power of one compute unit is recorded at 64bit MSR. + +Let me calculate the extreme case that how long does it take before +overflow: + +Use power consumption 15w, max power 2^64 = 1.8 * 10^19 +mWatt-ptsc_loops, and PTSC freqency 100 MHz: + + 1.8 * 10^19 = (15,000) * (Tmax/Tcycle) + 1.8 * 10^19 = (15,000) * (Tmax * PTSC_Freq) + 1.8 * 10^19 = (15,000) * (Tmax * 100,000,000) + Tmax = 1.2 * 10^7 seconds + +Thanks +Rui diff --git a/a/content_digest b/N1/content_digest index 289b65d..61ef6a3 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -4,8 +4,8 @@ "ref\020150828104525.GD4191@hr-slim.amd.com\0" "ref\055E06A99.7070800@roeck-us.net\0" "From\0Huang Rui <ray.huang@amd.com>\0" - "Subject\0Re: [lm-sensors] [PATCH 12/15] hwmon, fam15h_power: introduce a cpu accumulated power reporting algo\0" - "Date\0Mon, 31 Aug 2015 04:16:07 +0000\0" + "Subject\0Re: [PATCH 12/15] hwmon, fam15h_power: introduce a cpu accumulated power reporting algorithm\0" + "Date\0Mon, 31 Aug 2015 12:16:07 +0800\0" "To\0Guenter Roeck <linux@roeck-us.net>\0" "Cc\0Borislav Petkov <bp@suse.de>" Jean Delvare <jdelvare@suse.de> @@ -29,105 +29,148 @@ " Tony Li <tony.li@amd.com>\0" "\00:1\0" "b\0" - "T24gRnJpLCBBdWcgMjgsIDIwMTUgYXQgMDc6MDU6MTNBTSAtMDcwMCwgR3VlbnRlciBSb2VjayB3\n" - "cm90ZToKPiBPbiAwOC8yOC8yMDE1IDAzOjQ1IEFNLCBIdWFuZyBSdWkgd3JvdGU6Cj4gPk9uIFRo\n" - "dSwgQXVnIDI3LCAyMDE1IGF0IDEwOjMwOjQzQU0gLTA3MDAsIEd1ZW50ZXIgUm9lY2sgd3JvdGU6\n" - "Cj4gPj5PbiBUaHUsIEF1ZyAyNywgMjAxNSBhdCAwNDowNzo0M1BNICswODAwLCBIdWFuZyBSdWkg\n" - "d3JvdGU6Cj4gPj4+VGhpcyBwYXRjaCBpbnRyb2R1Y2VzIGFuIGFsZ29yaXRobSB0aGF0IGNvbXB1\n" - "dGVzIHRoZSBhdmVyYWdlIHBvd2VyIGJ5Cj4gPj4+cmVhZGluZyBhIGRlbHRhIHZhbHVlIG9mIOKA\n" - "nGNvcmUgcG93ZXIgYWNjdW11bGF0b3LigJ0gcmVnaXN0ZXIgZHVyaW5nCj4gPj4+bWVhc3VyZW1l\n" - "bnQgaW50ZXJ2YWwsIGFuZCB0aGVuIGRpdmlkaW5nIGRlbHRhIHZhbHVlIGJ5IHRoZSBsZW5ndGgg\n" - "b2YKPiA+Pj50aGUgdGltZSBpbnRlcnZhbC4KPiA+Pj4KPiA+Pj5Vc2VyIGlzIGFibGUgdG8gdXNl\n" - "IHBvd2VyMV9hY2MgZW50cnkgdG8gbWVhc3VyZSB0aGUgcHJvY2Vzc29yIHBvd2VyCj4gPj4+Y29u\n" - "c3VtcHRpb24gYW5kIHBvd2VyMV9hY2MganVzdCBuZWVkcyB0byBiZSByZWFkIHR3aWNlIHdpdGgg\n" - "YW4gbmVlZGVkCj4gPj4+aW50ZXJ2YWwgaW4tYmV0d2Vlbi4KPiA+Pj4KPiA+Pj5BIHNpbXBsZSBl\n" - "eGFtcGxlOgo+ID4+Pgo+ID4+PiQgY2F0IC9zeXMvYnVzL3BjaS9kZXZpY2VzLzAwMDBcOjAwXDox\n" - "OC40L2h3bW9uL2h3bW9uMC9wb3dlcjFfYWNjCj4gPj4+JCBzbGVlcCAxMDAwMHMKPiA+Pj4kIGNh\n" - "dCAvc3lzL2J1cy9wY2kvZGV2aWNlcy8wMDAwXDowMFw6MTguNC9od21vbi9od21vbjAvcG93ZXIx\n" - "X2FjYwo+ID4+Pgo+ID4+PlRoZSByZXN1bHQgaXMgY3VycmVudCBhdmVyYWdlIHByb2Nlc3NvciBw\n" - "b3dlciBjb25zdW1wdGlvbiBpbiAxMDAwMAo+ID4+PnNlY29uZHMuIFRoZSB1bml0IG9mIHRoZSBy\n" - "ZXN1bHQgaXMgdVdhdHQuCj4gPj4+Cj4gPj4+U2lnbmVkLW9mZi1ieTogSHVhbmcgUnVpIDxyYXku\n" - "aHVhbmdAYW1kLmNvbT4KPiA+Pj4tLS0KPiA+Pj4gIGRyaXZlcnMvaHdtb24vZmFtMTVoX3Bvd2Vy\n" - "LmMgfCA2MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ID4+\n" - "PiAgMSBmaWxlIGNoYW5nZWQsIDYyIGluc2VydGlvbnMoKykKPiA+Pj4KPiA+Pj5kaWZmIC0tZ2l0\n" - "IGEvZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYyBiL2RyaXZlcnMvaHdtb24vZmFtMTVoX3Bv\n" - "d2VyLmMKPiA+Pj5pbmRleCBkNTI5ZTRiLi4zYmFiNzk3IDEwMDY0NAo+ID4+Pi0tLSBhL2RyaXZl\n" - "cnMvaHdtb24vZmFtMTVoX3Bvd2VyLmMKPiA+Pj4rKysgYi9kcml2ZXJzL2h3bW9uL2ZhbTE1aF9w\n" - "b3dlci5jCj4gPj4+QEAgLTYwLDYgKzYwLDcgQEAgc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhIHsK\n" - "PiA+Pj4gIAl1NjQgY3VfYWNjX3Bvd2VyW01BWF9DVVNdOwo+ID4+PiAgCS8qIHBlcmZvcm1hbmNl\n" - "IHRpbWVzdGFtcCBjb3VudGVyICovCj4gPj4+ICAJdTY0IGNwdV9zd19wd3JfcHRzY1tNQVhfQ1VT\n" - "XTsKPiA+Pj4rCXN0cnVjdCBtdXRleCBhY2NfcHdyX211dGV4Owo+ID4+PiAgfTsKPiA+Pj4KPiA+\n" - "Pj4gIHN0YXRpYyBzc2l6ZV90IHNob3dfcG93ZXIoc3RydWN0IGRldmljZSAqZGV2LAo+ID4+PkBA\n" - "IC0xMjEsMTcgKzEyMiw3NCBAQCBzdGF0aWMgREVWSUNFX0FUVFIocG93ZXIxX2NyaXQsIFNfSVJV\n" - "R08sIHNob3dfcG93ZXJfY3JpdCwgTlVMTCk7Cj4gPj4+ICBzdGF0aWMgc3RydWN0IGF0dHJpYnV0\n" - "ZV9ncm91cCBmYW0xNWhfcG93ZXJfZ3JvdXA7Cj4gPj4+ICBfX0FUVFJJQlVURV9HUk9VUFMoZmFt\n" - "MTVoX3Bvd2VyKTsKPiA+Pj4KPiA+Pj4rc3RhdGljIHNzaXplX3Qgc2hvd19wb3dlcl9hY2Moc3Ry\n" - "dWN0IGRldmljZSAqZGV2LAo+ID4+PisJCQkgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAq\n" - "YXR0ciwgY2hhciAqYnVmKQo+ID4+Pit7Cj4gPj4+KwlpbnQgY3B1LCBjdSwgY3VfbnVtLCBjb3Jl\n" - "c19wZXJfY3U7Cj4gPj4+Kwl1NjQgY3Vycl9jdV9hY2NfcG93ZXJbTUFYX0NVU10sCj4gPj4+Kwkg\n" - "ICAgY3Vycl9wdHNjW01BWF9DVVNdLCBqZGVsdGFbTUFYX0NVU107Cj4gPj4+Kwl1NjQgdGRlbHRh\n" - "LCBhdmdfYWNjOwo+ID4+PisJc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhICpkYXRhID0gZGV2X2dl\n" - "dF9kcnZkYXRhKGRldik7Cj4gPj4+Kwo+ID4+PisJY29yZXNfcGVyX2N1ID0gYW1kX2dldF9jb3Jl\n" - "c19wZXJfY3UoKTsKPiA+Pj4rCWN1X251bSA9IGJvb3RfY3B1X2RhdGEueDg2X21heF9jb3JlcyAv\n" - "IGNvcmVzX3Blcl9jdTsKPiA+Pj4rCj4gPj4+Kwlmb3IgKGNwdSA9IDAsIGF2Z19hY2MgPSAwOyBj\n" - "cHUgPCBjdV9udW0gKiBjb3Jlc19wZXJfY3U7IGNwdSArPSBjb3Jlc19wZXJfY3UpIHsKPiA+Pj4r\n" - "CQljdSA9IGNwdSAvIGNvcmVzX3Blcl9jdTsKPiA+Pj4rCQlpZiAocmRtc3JsX3NhZmVfb25fY3B1\n" - "KGNwdSwgTVNSX0YxNUhfUFRTQywgJmN1cnJfcHRzY1tjdV0pKSB7Cj4gPj4+KwkJCXByX2Vycigi\n" - "RmFpbGVkIHRvIHJlYWQgUFRTQyBjb3VudGVyIE1TUiBvbiBjb3JlJWRcbiIsCj4gPj4+KwkJCSAg\n" - "ICAgICBjcHUpOwo+ID4+PisJCQlyZXR1cm4gMDsKPiA+Pj4rCQl9Cj4gPj4+Kwo+ID4+PisJCWlm\n" - "IChyZG1zcmxfc2FmZV9vbl9jcHUoY3B1LCBNU1JfRjE1SF9DVV9QV1JfQUNDVU1VTEFUT1IsCj4g\n" - "Pj4+KwkJCQkgICAgICAgJmN1cnJfY3VfYWNjX3Bvd2VyW2N1XSkpIHsKPiA+Pj4rCQkJcHJfZXJy\n" - "KCJGYWlsZWQgdG8gcmVhZCBjb21wdXRlIHVuaXQgcG93ZXIgYWNjdW11bGF0b3IgTVNSIG9uIGNv\n" - "cmUlZFxuIiwKPiA+Pj4rCQkJICAgICAgIGNwdSk7Cj4gPj4+KwkJCXJldHVybiAwOwo+ID4+PisJ\n" - "CX0KPiA+Pj4rCj4gPj4+KwkJaWYgKGN1cnJfY3VfYWNjX3Bvd2VyW2N1XSA8IGRhdGEtPmN1X2Fj\n" - "Y19wb3dlcltjdV0pIHsKPiA+Pj4rCQkJamRlbHRhW2N1XSA9IGRhdGEtPm1heF9jdV9hY2NfcG93\n" - "ZXIgKyBjdXJyX2N1X2FjY19wb3dlcltjdV07Cj4gPj4+KwkJCWpkZWx0YVtjdV0gLT0gZGF0YS0+\n" - "Y3VfYWNjX3Bvd2VyW2N1XTsKPiA+Pj4rCQl9IGVsc2Ugewo+ID4+PisJCQlqZGVsdGFbY3VdID0g\n" - "Y3Vycl9jdV9hY2NfcG93ZXJbY3VdIC0gZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XTsKPiA+Pj4rCQl9\n" - "Cj4gPj4+KwkJdGRlbHRhID0gY3Vycl9wdHNjW2N1XSAtIGRhdGEtPmNwdV9zd19wd3JfcHRzY1tj\n" - "dV07Cj4gPj4+KwkJamRlbHRhW2N1XSAqPSBkYXRhLT5jcHVfcHdyX3NhbXBsZV9yYXRpbyAqIDEw\n" - "MDA7Cj4gPj4+KwkJZG9fZGl2KGpkZWx0YVtjdV0sIHRkZWx0YSk7Cj4gPj4+Kwo+ID4+PisJCW11\n" - "dGV4X2xvY2soJmRhdGEtPmFjY19wd3JfbXV0ZXgpOwo+ID4+PisJCWRhdGEtPmN1X2FjY19wb3dl\n" - "cltjdV0gPSBjdXJyX2N1X2FjY19wb3dlcltjdV07Cj4gPj4+KwkJZGF0YS0+Y3B1X3N3X3B3cl9w\n" - "dHNjW2N1XSA9IGN1cnJfcHRzY1tjdV07Cj4gPj4+KwkJbXV0ZXhfdW5sb2NrKCZkYXRhLT5hY2Nf\n" - "cHdyX211dGV4KTsKPiA+Pj4rCj4gPj4+KwkJLyogdGhlIHVuaXQgaXMgbWljcm9XYXR0ICovCj4g\n" - "Pj4+KwkJYXZnX2FjYyArPSBqZGVsdGFbY3VdOwo+ID4+PisJfQo+ID4+PisKPiA+Pj4rCXJldHVy\n" - "biBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCAodW5zaWduZWQgaW50KSBhdmdfYWNjKTsKPiA+Pj4rfQo+\n" - "ID4+PitzdGF0aWMgREVWSUNFX0FUVFIocG93ZXIxX2FjYywgU19JUlVHTywgc2hvd19wb3dlcl9h\n" - "Y2MsIE5VTEwpOwo+ID4+Cj4gPj5JIGFtIG5vdCByZWFsbHkgYSBmcmllbmQgb2YgaW50cm9kdWNp\n" - "bmcgYSBub24tc3RhbmRhcmQgYXR0cmlidXRlLgo+ID4+RG9lcyB0aGUgZW5lcmd5IGF0dHJpYnV0\n" - "ZSBub3Qgd29yayBoZXJlID8KPiA+Pgo+ID4KPiA+WW91J3JlIHJpZ2h0LiBOb24tc3RhbmRhcmQg\n" - "YXR0cmlidXRlIG1pZ2h0IG5vdCBiZSBnb29kLiBDb3VsZCB5b3UKPiA+cGxlYXNlIGdpdmUgbWUg\n" - "c29tZSBoaW50cyBpZiBJIHVzZSAiZW5lcmd5IiBpbnN0ZWFkPwo+ID4KPiAxIEpvdWxlID0gMSBX\n" - "YXR0LXNlY29uZC4KPiAKPiBTb21ldGhpbmcgZWxzZSwgdGhvdWdoIC0gZGlkIHlvdSBtYWtlIHN1\n" - "cmUgdGhhdCB5b3VyIGNvZGUgZG9lc24ndCBvdmVyZmxvdyA/Cj4gRXZlbiB0aG91Z2ggeW91IGNh\n" - "bGN1bGF0ZSB0aGUgYXZlcmFnZSBpbiBhbiB1NjQsIHlvdSBkaXNwbGF5IGl0IGFzIHVuc2lnbmVk\n" - "Lgo+IAoKVGhhbmtzIHRvIHlvdXIgcmVtaW5kZXIuIEl0IHNob3VsZCBub3QgYmUgb3ZlcmZsb3cu\n" - "IFRoZSBtYXhpbXVtIHBvd2VyCmNvbnN1bXB0aW9uIG9mIHByb2Nlc3NvciAoQU1EIENaIGFuZCBm\n" - "dXR1cmUgMTVoKSBpcyBhYm91dCAxNSBXYXR0cyA9CjE1LDAwMCwwMDAgdVdhdHRzID0gMHhFNEUx\n" - "QzAgdVdhdHRzLCB0aGUgc2l6ZSBpcyAyNCA8IDMyIDwgNjQgYml0cy4KCkFjdHVhbGx5LCB0aGUg\n" - "dW5pdCBvZiBqZGVsdGEgaXMgbm90IEpvdWxlLiBCZWNhdXNlIHRoZSB0ZGVsdGEgaXMgdGhlCmxv\n" - "b3BzIChjeWNsZXMpIHRoYXQgUFRTQyBjb3VudGVyICh0aGUgZnJlcWVuY3kgaXMgYWJvdXQgMTAw\n" - "IE1IeikKY291bnRzIG5vdCBzZWNvbmRzLgoKU28gYXZnX2FjYyBpcyB0aGUgYXZlcmFnZSBwb3dl\n" - "ciBjb25zdW1wdGlvbiBub3QgdGhlIGFjY3VtdWxhdGVkIGVuZXJneS4KCj4gMTAwdyAqIDEwLDAw\n" - "MHMgPSAxLDAwMCwwMDB3cyA9IDEsMDAwLDAwMCwwMDAsMDAwIG1pY3JvLXdhdHQtc2Vjb25kcywg\n" - "d2hpY2ggaXMKPiBhIGJpdCBsYXJnZSBmb3IgYW4gdW5zaWduZWQuCj4gCj4gQWxzbywgdGhlIHZh\n" - "bHVlcyBzaG91bGQgbm90IGJlIHJlc2V0IGFmdGVyIHJlYWRpbmcsIGJ1dCBhY2N1bXVsYXRlLgo+\n" - "IAo+IEFsc28sIEkgdGhpbmsgeW91ciBjb2RlIG1heSBiZSB2dWxuZXJhYmxlIHRvIG92ZXJmbG93\n" - "cyBvbiB0aGUgQ1BVIHJlZ2lzdGVyIHNpZGUuCj4gSG93IGxvbmcgZG9lcyBpdCB0YWtlIGJlZm9y\n" - "ZSB0aGUgQ1BVIGNvdW50ZXJzIG92ZXJmbG93ID8KPiAKCklmIEkgdXNlICJlbmVyZ3kiLCAxNXcg\n" - "KiAxMCwwMDBzID0gMTUwLDAwMCwwMDAsMDAwIG1pY3JvV2F0dC1zZWNvbmRzLgpZZXMsIGl0J3Mg\n" - "bGFyZ2UgZm9yIGFuIHVuc2lnbmVkLCBidXQgc3VpdGFibGUgZm9yIHU2NC4KClRoZSBhY2N1bXVs\n" - "YXRlZCBwb3dlciBvZiBvbmUgY29tcHV0ZSB1bml0IGlzIHJlY29yZGVkIGF0IDY0Yml0IE1TUi4K\n" - "CkxldCBtZSBjYWxjdWxhdGUgdGhlIGV4dHJlbWUgY2FzZSB0aGF0IGhvdyBsb25nIGRvZXMgaXQg\n" - "dGFrZSBiZWZvcmUKb3ZlcmZsb3c6CgpVc2UgcG93ZXIgY29uc3VtcHRpb24gMTV3LCBtYXggcG93\n" - "ZXIgMl42NCA9IDEuOCAqIDEwXjE5Cm1XYXR0LXB0c2NfbG9vcHMsIGFuZCBQVFNDIGZyZXFlbmN5\n" - "IDEwMCBNSHo6CgogICAgICAgIDEuOCAqIDEwXjE5ID0gKDE1LDAwMCkgKiAoVG1heC9UY3ljbGUp\n" - "CiAgICAgICAgMS44ICogMTBeMTkgPSAoMTUsMDAwKSAqIChUbWF4ICogUFRTQ19GcmVxKQogICAg\n" - "ICAgIDEuOCAqIDEwXjE5ID0gKDE1LDAwMCkgKiAoVG1heCAqIDEwMCwwMDAsMDAwKQogICAgICAg\n" - "IFRtYXggPSAxLjIgKiAxMF43IHNlY29uZHMKClRoYW5rcwpSdWkKCl9fX19fX19fX19fX19fX19f\n" - "X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0Cmxt\n" - "LXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxt\n" - YW4vbGlzdGluZm8vbG0tc2Vuc29ycw= + "On Fri, Aug 28, 2015 at 07:05:13AM -0700, Guenter Roeck wrote:\n" + "> On 08/28/2015 03:45 AM, Huang Rui wrote:\n" + "> >On Thu, Aug 27, 2015 at 10:30:43AM -0700, Guenter Roeck wrote:\n" + "> >>On Thu, Aug 27, 2015 at 04:07:43PM +0800, Huang Rui wrote:\n" + "> >>>This patch introduces an algorithm that computes the average power by\n" + "> >>>reading a delta value of \342\200\234core power accumulator\342\200\235 register during\n" + "> >>>measurement interval, and then dividing delta value by the length of\n" + "> >>>the time interval.\n" + "> >>>\n" + "> >>>User is able to use power1_acc entry to measure the processor power\n" + "> >>>consumption and power1_acc just needs to be read twice with an needed\n" + "> >>>interval in-between.\n" + "> >>>\n" + "> >>>A simple example:\n" + "> >>>\n" + "> >>>$ cat /sys/bus/pci/devices/0000\\:00\\:18.4/hwmon/hwmon0/power1_acc\n" + "> >>>$ sleep 10000s\n" + "> >>>$ cat /sys/bus/pci/devices/0000\\:00\\:18.4/hwmon/hwmon0/power1_acc\n" + "> >>>\n" + "> >>>The result is current average processor power consumption in 10000\n" + "> >>>seconds. The unit of the result is uWatt.\n" + "> >>>\n" + "> >>>Signed-off-by: Huang Rui <ray.huang@amd.com>\n" + "> >>>---\n" + "> >>> drivers/hwmon/fam15h_power.c | 62 ++++++++++++++++++++++++++++++++++++++++++++\n" + "> >>> 1 file changed, 62 insertions(+)\n" + "> >>>\n" + "> >>>diff --git a/drivers/hwmon/fam15h_power.c b/drivers/hwmon/fam15h_power.c\n" + "> >>>index d529e4b..3bab797 100644\n" + "> >>>--- a/drivers/hwmon/fam15h_power.c\n" + "> >>>+++ b/drivers/hwmon/fam15h_power.c\n" + "> >>>@@ -60,6 +60,7 @@ struct fam15h_power_data {\n" + "> >>> \tu64 cu_acc_power[MAX_CUS];\n" + "> >>> \t/* performance timestamp counter */\n" + "> >>> \tu64 cpu_sw_pwr_ptsc[MAX_CUS];\n" + "> >>>+\tstruct mutex acc_pwr_mutex;\n" + "> >>> };\n" + "> >>>\n" + "> >>> static ssize_t show_power(struct device *dev,\n" + "> >>>@@ -121,17 +122,74 @@ static DEVICE_ATTR(power1_crit, S_IRUGO, show_power_crit, NULL);\n" + "> >>> static struct attribute_group fam15h_power_group;\n" + "> >>> __ATTRIBUTE_GROUPS(fam15h_power);\n" + "> >>>\n" + "> >>>+static ssize_t show_power_acc(struct device *dev,\n" + "> >>>+\t\t\t struct device_attribute *attr, char *buf)\n" + "> >>>+{\n" + "> >>>+\tint cpu, cu, cu_num, cores_per_cu;\n" + "> >>>+\tu64 curr_cu_acc_power[MAX_CUS],\n" + "> >>>+\t curr_ptsc[MAX_CUS], jdelta[MAX_CUS];\n" + "> >>>+\tu64 tdelta, avg_acc;\n" + "> >>>+\tstruct fam15h_power_data *data = dev_get_drvdata(dev);\n" + "> >>>+\n" + "> >>>+\tcores_per_cu = amd_get_cores_per_cu();\n" + "> >>>+\tcu_num = boot_cpu_data.x86_max_cores / cores_per_cu;\n" + "> >>>+\n" + "> >>>+\tfor (cpu = 0, avg_acc = 0; cpu < cu_num * cores_per_cu; cpu += cores_per_cu) {\n" + "> >>>+\t\tcu = cpu / cores_per_cu;\n" + "> >>>+\t\tif (rdmsrl_safe_on_cpu(cpu, MSR_F15H_PTSC, &curr_ptsc[cu])) {\n" + "> >>>+\t\t\tpr_err(\"Failed to read PTSC counter MSR on core%d\\n\",\n" + "> >>>+\t\t\t cpu);\n" + "> >>>+\t\t\treturn 0;\n" + "> >>>+\t\t}\n" + "> >>>+\n" + "> >>>+\t\tif (rdmsrl_safe_on_cpu(cpu, MSR_F15H_CU_PWR_ACCUMULATOR,\n" + "> >>>+\t\t\t\t &curr_cu_acc_power[cu])) {\n" + "> >>>+\t\t\tpr_err(\"Failed to read compute unit power accumulator MSR on core%d\\n\",\n" + "> >>>+\t\t\t cpu);\n" + "> >>>+\t\t\treturn 0;\n" + "> >>>+\t\t}\n" + "> >>>+\n" + "> >>>+\t\tif (curr_cu_acc_power[cu] < data->cu_acc_power[cu]) {\n" + "> >>>+\t\t\tjdelta[cu] = data->max_cu_acc_power + curr_cu_acc_power[cu];\n" + "> >>>+\t\t\tjdelta[cu] -= data->cu_acc_power[cu];\n" + "> >>>+\t\t} else {\n" + "> >>>+\t\t\tjdelta[cu] = curr_cu_acc_power[cu] - data->cu_acc_power[cu];\n" + "> >>>+\t\t}\n" + "> >>>+\t\ttdelta = curr_ptsc[cu] - data->cpu_sw_pwr_ptsc[cu];\n" + "> >>>+\t\tjdelta[cu] *= data->cpu_pwr_sample_ratio * 1000;\n" + "> >>>+\t\tdo_div(jdelta[cu], tdelta);\n" + "> >>>+\n" + "> >>>+\t\tmutex_lock(&data->acc_pwr_mutex);\n" + "> >>>+\t\tdata->cu_acc_power[cu] = curr_cu_acc_power[cu];\n" + "> >>>+\t\tdata->cpu_sw_pwr_ptsc[cu] = curr_ptsc[cu];\n" + "> >>>+\t\tmutex_unlock(&data->acc_pwr_mutex);\n" + "> >>>+\n" + "> >>>+\t\t/* the unit is microWatt */\n" + "> >>>+\t\tavg_acc += jdelta[cu];\n" + "> >>>+\t}\n" + "> >>>+\n" + "> >>>+\treturn sprintf(buf, \"%u\\n\", (unsigned int) avg_acc);\n" + "> >>>+}\n" + "> >>>+static DEVICE_ATTR(power1_acc, S_IRUGO, show_power_acc, NULL);\n" + "> >>\n" + "> >>I am not really a friend of introducing a non-standard attribute.\n" + "> >>Does the energy attribute not work here ?\n" + "> >>\n" + "> >\n" + "> >You're right. Non-standard attribute might not be good. Could you\n" + "> >please give me some hints if I use \"energy\" instead?\n" + "> >\n" + "> 1 Joule = 1 Watt-second.\n" + "> \n" + "> Something else, though - did you make sure that your code doesn't overflow ?\n" + "> Even though you calculate the average in an u64, you display it as unsigned.\n" + "> \n" + "\n" + "Thanks to your reminder. It should not be overflow. The maximum power\n" + "consumption of processor (AMD CZ and future 15h) is about 15 Watts =\n" + "15,000,000 uWatts = 0xE4E1C0 uWatts, the size is 24 < 32 < 64 bits.\n" + "\n" + "Actually, the unit of jdelta is not Joule. Because the tdelta is the\n" + "loops (cycles) that PTSC counter (the freqency is about 100 MHz)\n" + "counts not seconds.\n" + "\n" + "So avg_acc is the average power consumption not the accumulated energy.\n" + "\n" + "> 100w * 10,000s = 1,000,000ws = 1,000,000,000,000 micro-watt-seconds, which is\n" + "> a bit large for an unsigned.\n" + "> \n" + "> Also, the values should not be reset after reading, but accumulate.\n" + "> \n" + "> Also, I think your code may be vulnerable to overflows on the CPU register side.\n" + "> How long does it take before the CPU counters overflow ?\n" + "> \n" + "\n" + "If I use \"energy\", 15w * 10,000s = 150,000,000,000 microWatt-seconds.\n" + "Yes, it's large for an unsigned, but suitable for u64.\n" + "\n" + "The accumulated power of one compute unit is recorded at 64bit MSR.\n" + "\n" + "Let me calculate the extreme case that how long does it take before\n" + "overflow:\n" + "\n" + "Use power consumption 15w, max power 2^64 = 1.8 * 10^19\n" + "mWatt-ptsc_loops, and PTSC freqency 100 MHz:\n" + "\n" + " 1.8 * 10^19 = (15,000) * (Tmax/Tcycle)\n" + " 1.8 * 10^19 = (15,000) * (Tmax * PTSC_Freq)\n" + " 1.8 * 10^19 = (15,000) * (Tmax * 100,000,000)\n" + " Tmax = 1.2 * 10^7 seconds\n" + "\n" + "Thanks\n" + Rui -c40d190c86973ef351cab724f5a11d4397aaca35bcfa0021efda2324420dd0a6 +d97628f88b680c0fe964fe581af1a64cc3552689e3b47fc51c669258c82e43f4
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.