diff for duplicates of <20150828104525.GD4191@hr-slim.amd.com> diff --git a/a/1.txt b/N1/1.txt index 6099250..34f5eeb 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,69 +1,100 @@ -T24gVGh1LCBBdWcgMjcsIDIwMTUgYXQgMTA6MzA6NDNBTSAtMDcwMCwgR3VlbnRlciBSb2VjayB3 -cm90ZToKPiBPbiBUaHUsIEF1ZyAyNywgMjAxNSBhdCAwNDowNzo0M1BNICswODAwLCBIdWFuZyBS -dWkgd3JvdGU6Cj4gPiBUaGlzIHBhdGNoIGludHJvZHVjZXMgYW4gYWxnb3JpdGhtIHRoYXQgY29t -cHV0ZXMgdGhlIGF2ZXJhZ2UgcG93ZXIgYnkKPiA+IHJlYWRpbmcgYSBkZWx0YSB2YWx1ZSBvZiDi -gJxjb3JlIHBvd2VyIGFjY3VtdWxhdG9y4oCdIHJlZ2lzdGVyIGR1cmluZwo+ID4gbWVhc3VyZW1l -bnQgaW50ZXJ2YWwsIGFuZCB0aGVuIGRpdmlkaW5nIGRlbHRhIHZhbHVlIGJ5IHRoZSBsZW5ndGgg -b2YKPiA+IHRoZSB0aW1lIGludGVydmFsLgo+ID4gCj4gPiBVc2VyIGlzIGFibGUgdG8gdXNlIHBv -d2VyMV9hY2MgZW50cnkgdG8gbWVhc3VyZSB0aGUgcHJvY2Vzc29yIHBvd2VyCj4gPiBjb25zdW1w -dGlvbiBhbmQgcG93ZXIxX2FjYyBqdXN0IG5lZWRzIHRvIGJlIHJlYWQgdHdpY2Ugd2l0aCBhbiBu -ZWVkZWQKPiA+IGludGVydmFsIGluLWJldHdlZW4uCj4gPiAKPiA+IEEgc2ltcGxlIGV4YW1wbGU6 -Cj4gPiAKPiA+ICQgY2F0IC9zeXMvYnVzL3BjaS9kZXZpY2VzLzAwMDBcOjAwXDoxOC40L2h3bW9u -L2h3bW9uMC9wb3dlcjFfYWNjCj4gPiAkIHNsZWVwIDEwMDAwcwo+ID4gJCBjYXQgL3N5cy9idXMv -cGNpL2RldmljZXMvMDAwMFw6MDBcOjE4LjQvaHdtb24vaHdtb24wL3Bvd2VyMV9hY2MKPiA+IAo+ -ID4gVGhlIHJlc3VsdCBpcyBjdXJyZW50IGF2ZXJhZ2UgcHJvY2Vzc29yIHBvd2VyIGNvbnN1bXB0 -aW9uIGluIDEwMDAwCj4gPiBzZWNvbmRzLiBUaGUgdW5pdCBvZiB0aGUgcmVzdWx0IGlzIHVXYXR0 -Lgo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5OiBIdWFuZyBSdWkgPHJheS5odWFuZ0BhbWQuY29tPgo+ -ID4gLS0tCj4gPiAgZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYyB8IDYyICsrKysrKysrKysr -KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gPiAgMSBmaWxlIGNoYW5nZWQsIDYy -IGluc2VydGlvbnMoKykKPiA+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vZmFtMTVo -X3Bvd2VyLmMgYi9kcml2ZXJzL2h3bW9uL2ZhbTE1aF9wb3dlci5jCj4gPiBpbmRleCBkNTI5ZTRi -Li4zYmFiNzk3IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYwo+ -ID4gKysrIGIvZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYwo+ID4gQEAgLTYwLDYgKzYwLDcg -QEAgc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhIHsKPiA+ICAJdTY0IGN1X2FjY19wb3dlcltNQVhf -Q1VTXTsKPiA+ICAJLyogcGVyZm9ybWFuY2UgdGltZXN0YW1wIGNvdW50ZXIgKi8KPiA+ICAJdTY0 -IGNwdV9zd19wd3JfcHRzY1tNQVhfQ1VTXTsKPiA+ICsJc3RydWN0IG11dGV4IGFjY19wd3JfbXV0 -ZXg7Cj4gPiAgfTsKPiA+ICAKPiA+ICBzdGF0aWMgc3NpemVfdCBzaG93X3Bvd2VyKHN0cnVjdCBk -ZXZpY2UgKmRldiwKPiA+IEBAIC0xMjEsMTcgKzEyMiw3NCBAQCBzdGF0aWMgREVWSUNFX0FUVFIo -cG93ZXIxX2NyaXQsIFNfSVJVR08sIHNob3dfcG93ZXJfY3JpdCwgTlVMTCk7Cj4gPiAgc3RhdGlj -IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgZmFtMTVoX3Bvd2VyX2dyb3VwOwo+ID4gIF9fQVRUUklC -VVRFX0dST1VQUyhmYW0xNWhfcG93ZXIpOwo+ID4gIAo+ID4gK3N0YXRpYyBzc2l6ZV90IHNob3df -cG93ZXJfYWNjKHN0cnVjdCBkZXZpY2UgKmRldiwKPiA+ICsJCQkgICAgICBzdHJ1Y3QgZGV2aWNl -X2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQo+ID4gK3sKPiA+ICsJaW50IGNwdSwgY3UsIGN1 -X251bSwgY29yZXNfcGVyX2N1Owo+ID4gKwl1NjQgY3Vycl9jdV9hY2NfcG93ZXJbTUFYX0NVU10s -Cj4gPiArCSAgICBjdXJyX3B0c2NbTUFYX0NVU10sIGpkZWx0YVtNQVhfQ1VTXTsKPiA+ICsJdTY0 -IHRkZWx0YSwgYXZnX2FjYzsKPiA+ICsJc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhICpkYXRhID0g -ZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gPiArCj4gPiArCWNvcmVzX3Blcl9jdSA9IGFtZF9nZXRf -Y29yZXNfcGVyX2N1KCk7Cj4gPiArCWN1X251bSA9IGJvb3RfY3B1X2RhdGEueDg2X21heF9jb3Jl -cyAvIGNvcmVzX3Blcl9jdTsKPiA+ICsKPiA+ICsJZm9yIChjcHUgPSAwLCBhdmdfYWNjID0gMDsg -Y3B1IDwgY3VfbnVtICogY29yZXNfcGVyX2N1OyBjcHUgKz0gY29yZXNfcGVyX2N1KSB7Cj4gPiAr -CQljdSA9IGNwdSAvIGNvcmVzX3Blcl9jdTsKPiA+ICsJCWlmIChyZG1zcmxfc2FmZV9vbl9jcHUo -Y3B1LCBNU1JfRjE1SF9QVFNDLCAmY3Vycl9wdHNjW2N1XSkpIHsKPiA+ICsJCQlwcl9lcnIoIkZh -aWxlZCB0byByZWFkIFBUU0MgY291bnRlciBNU1Igb24gY29yZSVkXG4iLAo+ID4gKwkJCSAgICAg -ICBjcHUpOwo+ID4gKwkJCXJldHVybiAwOwo+ID4gKwkJfQo+ID4gKwo+ID4gKwkJaWYgKHJkbXNy -bF9zYWZlX29uX2NwdShjcHUsIE1TUl9GMTVIX0NVX1BXUl9BQ0NVTVVMQVRPUiwKPiA+ICsJCQkJ -ICAgICAgICZjdXJyX2N1X2FjY19wb3dlcltjdV0pKSB7Cj4gPiArCQkJcHJfZXJyKCJGYWlsZWQg -dG8gcmVhZCBjb21wdXRlIHVuaXQgcG93ZXIgYWNjdW11bGF0b3IgTVNSIG9uIGNvcmUlZFxuIiwK -PiA+ICsJCQkgICAgICAgY3B1KTsKPiA+ICsJCQlyZXR1cm4gMDsKPiA+ICsJCX0KPiA+ICsKPiA+ -ICsJCWlmIChjdXJyX2N1X2FjY19wb3dlcltjdV0gPCBkYXRhLT5jdV9hY2NfcG93ZXJbY3VdKSB7 -Cj4gPiArCQkJamRlbHRhW2N1XSA9IGRhdGEtPm1heF9jdV9hY2NfcG93ZXIgKyBjdXJyX2N1X2Fj -Y19wb3dlcltjdV07Cj4gPiArCQkJamRlbHRhW2N1XSAtPSBkYXRhLT5jdV9hY2NfcG93ZXJbY3Vd -Owo+ID4gKwkJfSBlbHNlIHsKPiA+ICsJCQlqZGVsdGFbY3VdID0gY3Vycl9jdV9hY2NfcG93ZXJb -Y3VdIC0gZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XTsKPiA+ICsJCX0KPiA+ICsJCXRkZWx0YSA9IGN1 -cnJfcHRzY1tjdV0gLSBkYXRhLT5jcHVfc3dfcHdyX3B0c2NbY3VdOwo+ID4gKwkJamRlbHRhW2N1 -XSAqPSBkYXRhLT5jcHVfcHdyX3NhbXBsZV9yYXRpbyAqIDEwMDA7Cj4gPiArCQlkb19kaXYoamRl -bHRhW2N1XSwgdGRlbHRhKTsKPiA+ICsKPiA+ICsJCW11dGV4X2xvY2soJmRhdGEtPmFjY19wd3Jf -bXV0ZXgpOwo+ID4gKwkJZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XSA9IGN1cnJfY3VfYWNjX3Bvd2Vy -W2N1XTsKPiA+ICsJCWRhdGEtPmNwdV9zd19wd3JfcHRzY1tjdV0gPSBjdXJyX3B0c2NbY3VdOwo+ -ID4gKwkJbXV0ZXhfdW5sb2NrKCZkYXRhLT5hY2NfcHdyX211dGV4KTsKPiA+ICsKPiA+ICsJCS8q -IHRoZSB1bml0IGlzIG1pY3JvV2F0dCAqLwo+ID4gKwkJYXZnX2FjYyArPSBqZGVsdGFbY3VdOwo+ -ID4gKwl9Cj4gPiArCj4gPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCAodW5zaWduZWQg -aW50KSBhdmdfYWNjKTsKPiA+ICt9Cj4gPiArc3RhdGljIERFVklDRV9BVFRSKHBvd2VyMV9hY2Ms -IFNfSVJVR08sIHNob3dfcG93ZXJfYWNjLCBOVUxMKTsKPiAKPiBJIGFtIG5vdCByZWFsbHkgYSBm -cmllbmQgb2YgaW50cm9kdWNpbmcgYSBub24tc3RhbmRhcmQgYXR0cmlidXRlLgo+IERvZXMgdGhl -IGVuZXJneSBhdHRyaWJ1dGUgbm90IHdvcmsgaGVyZSA/Cj4gCgpZb3UncmUgcmlnaHQuIE5vbi1z -dGFuZGFyZCBhdHRyaWJ1dGUgbWlnaHQgbm90IGJlIGdvb2QuIENvdWxkIHlvdQpwbGVhc2UgZ2l2 -ZSBtZSBzb21lIGhpbnRzIGlmIEkgdXNlICJlbmVyZ3kiIGluc3RlYWQ/CgpUaGFua3MsClJ1aQoK -X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbG0tc2Vuc29y -cyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0t -c2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz +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? + +Thanks, +Rui diff --git a/a/content_digest b/N1/content_digest index 5f434a0..be88cb1 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -2,8 +2,8 @@ "ref\01440662866-28716-13-git-send-email-ray.huang@amd.com\0" "ref\020150827173043.GB27452@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\0Fri, 28 Aug 2015 10:45:25 +0000\0" + "Subject\0Re: [PATCH 12/15] hwmon, fam15h_power: introduce a cpu accumulated power reporting algorithm\0" + "Date\0Fri, 28 Aug 2015 18:45:25 +0800\0" "To\0Guenter Roeck <linux@roeck-us.net>\0" "Cc\0Borislav Petkov <bp@suse.de>" Jean Delvare <jdelvare@suse.de> @@ -27,74 +27,105 @@ " Tony Li <tony.li@amd.com>\0" "\00:1\0" "b\0" - "T24gVGh1LCBBdWcgMjcsIDIwMTUgYXQgMTA6MzA6NDNBTSAtMDcwMCwgR3VlbnRlciBSb2VjayB3\n" - "cm90ZToKPiBPbiBUaHUsIEF1ZyAyNywgMjAxNSBhdCAwNDowNzo0M1BNICswODAwLCBIdWFuZyBS\n" - "dWkgd3JvdGU6Cj4gPiBUaGlzIHBhdGNoIGludHJvZHVjZXMgYW4gYWxnb3JpdGhtIHRoYXQgY29t\n" - "cHV0ZXMgdGhlIGF2ZXJhZ2UgcG93ZXIgYnkKPiA+IHJlYWRpbmcgYSBkZWx0YSB2YWx1ZSBvZiDi\n" - "gJxjb3JlIHBvd2VyIGFjY3VtdWxhdG9y4oCdIHJlZ2lzdGVyIGR1cmluZwo+ID4gbWVhc3VyZW1l\n" - "bnQgaW50ZXJ2YWwsIGFuZCB0aGVuIGRpdmlkaW5nIGRlbHRhIHZhbHVlIGJ5IHRoZSBsZW5ndGgg\n" - "b2YKPiA+IHRoZSB0aW1lIGludGVydmFsLgo+ID4gCj4gPiBVc2VyIGlzIGFibGUgdG8gdXNlIHBv\n" - "d2VyMV9hY2MgZW50cnkgdG8gbWVhc3VyZSB0aGUgcHJvY2Vzc29yIHBvd2VyCj4gPiBjb25zdW1w\n" - "dGlvbiBhbmQgcG93ZXIxX2FjYyBqdXN0IG5lZWRzIHRvIGJlIHJlYWQgdHdpY2Ugd2l0aCBhbiBu\n" - "ZWVkZWQKPiA+IGludGVydmFsIGluLWJldHdlZW4uCj4gPiAKPiA+IEEgc2ltcGxlIGV4YW1wbGU6\n" - "Cj4gPiAKPiA+ICQgY2F0IC9zeXMvYnVzL3BjaS9kZXZpY2VzLzAwMDBcOjAwXDoxOC40L2h3bW9u\n" - "L2h3bW9uMC9wb3dlcjFfYWNjCj4gPiAkIHNsZWVwIDEwMDAwcwo+ID4gJCBjYXQgL3N5cy9idXMv\n" - "cGNpL2RldmljZXMvMDAwMFw6MDBcOjE4LjQvaHdtb24vaHdtb24wL3Bvd2VyMV9hY2MKPiA+IAo+\n" - "ID4gVGhlIHJlc3VsdCBpcyBjdXJyZW50IGF2ZXJhZ2UgcHJvY2Vzc29yIHBvd2VyIGNvbnN1bXB0\n" - "aW9uIGluIDEwMDAwCj4gPiBzZWNvbmRzLiBUaGUgdW5pdCBvZiB0aGUgcmVzdWx0IGlzIHVXYXR0\n" - "Lgo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5OiBIdWFuZyBSdWkgPHJheS5odWFuZ0BhbWQuY29tPgo+\n" - "ID4gLS0tCj4gPiAgZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYyB8IDYyICsrKysrKysrKysr\n" - "KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gPiAgMSBmaWxlIGNoYW5nZWQsIDYy\n" - "IGluc2VydGlvbnMoKykKPiA+IAo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vZmFtMTVo\n" - "X3Bvd2VyLmMgYi9kcml2ZXJzL2h3bW9uL2ZhbTE1aF9wb3dlci5jCj4gPiBpbmRleCBkNTI5ZTRi\n" - "Li4zYmFiNzk3IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYwo+\n" - "ID4gKysrIGIvZHJpdmVycy9od21vbi9mYW0xNWhfcG93ZXIuYwo+ID4gQEAgLTYwLDYgKzYwLDcg\n" - "QEAgc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhIHsKPiA+ICAJdTY0IGN1X2FjY19wb3dlcltNQVhf\n" - "Q1VTXTsKPiA+ICAJLyogcGVyZm9ybWFuY2UgdGltZXN0YW1wIGNvdW50ZXIgKi8KPiA+ICAJdTY0\n" - "IGNwdV9zd19wd3JfcHRzY1tNQVhfQ1VTXTsKPiA+ICsJc3RydWN0IG11dGV4IGFjY19wd3JfbXV0\n" - "ZXg7Cj4gPiAgfTsKPiA+ICAKPiA+ICBzdGF0aWMgc3NpemVfdCBzaG93X3Bvd2VyKHN0cnVjdCBk\n" - "ZXZpY2UgKmRldiwKPiA+IEBAIC0xMjEsMTcgKzEyMiw3NCBAQCBzdGF0aWMgREVWSUNFX0FUVFIo\n" - "cG93ZXIxX2NyaXQsIFNfSVJVR08sIHNob3dfcG93ZXJfY3JpdCwgTlVMTCk7Cj4gPiAgc3RhdGlj\n" - "IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgZmFtMTVoX3Bvd2VyX2dyb3VwOwo+ID4gIF9fQVRUUklC\n" - "VVRFX0dST1VQUyhmYW0xNWhfcG93ZXIpOwo+ID4gIAo+ID4gK3N0YXRpYyBzc2l6ZV90IHNob3df\n" - "cG93ZXJfYWNjKHN0cnVjdCBkZXZpY2UgKmRldiwKPiA+ICsJCQkgICAgICBzdHJ1Y3QgZGV2aWNl\n" - "X2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQo+ID4gK3sKPiA+ICsJaW50IGNwdSwgY3UsIGN1\n" - "X251bSwgY29yZXNfcGVyX2N1Owo+ID4gKwl1NjQgY3Vycl9jdV9hY2NfcG93ZXJbTUFYX0NVU10s\n" - "Cj4gPiArCSAgICBjdXJyX3B0c2NbTUFYX0NVU10sIGpkZWx0YVtNQVhfQ1VTXTsKPiA+ICsJdTY0\n" - "IHRkZWx0YSwgYXZnX2FjYzsKPiA+ICsJc3RydWN0IGZhbTE1aF9wb3dlcl9kYXRhICpkYXRhID0g\n" - "ZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gPiArCj4gPiArCWNvcmVzX3Blcl9jdSA9IGFtZF9nZXRf\n" - "Y29yZXNfcGVyX2N1KCk7Cj4gPiArCWN1X251bSA9IGJvb3RfY3B1X2RhdGEueDg2X21heF9jb3Jl\n" - "cyAvIGNvcmVzX3Blcl9jdTsKPiA+ICsKPiA+ICsJZm9yIChjcHUgPSAwLCBhdmdfYWNjID0gMDsg\n" - "Y3B1IDwgY3VfbnVtICogY29yZXNfcGVyX2N1OyBjcHUgKz0gY29yZXNfcGVyX2N1KSB7Cj4gPiAr\n" - "CQljdSA9IGNwdSAvIGNvcmVzX3Blcl9jdTsKPiA+ICsJCWlmIChyZG1zcmxfc2FmZV9vbl9jcHUo\n" - "Y3B1LCBNU1JfRjE1SF9QVFNDLCAmY3Vycl9wdHNjW2N1XSkpIHsKPiA+ICsJCQlwcl9lcnIoIkZh\n" - "aWxlZCB0byByZWFkIFBUU0MgY291bnRlciBNU1Igb24gY29yZSVkXG4iLAo+ID4gKwkJCSAgICAg\n" - "ICBjcHUpOwo+ID4gKwkJCXJldHVybiAwOwo+ID4gKwkJfQo+ID4gKwo+ID4gKwkJaWYgKHJkbXNy\n" - "bF9zYWZlX29uX2NwdShjcHUsIE1TUl9GMTVIX0NVX1BXUl9BQ0NVTVVMQVRPUiwKPiA+ICsJCQkJ\n" - "ICAgICAgICZjdXJyX2N1X2FjY19wb3dlcltjdV0pKSB7Cj4gPiArCQkJcHJfZXJyKCJGYWlsZWQg\n" - "dG8gcmVhZCBjb21wdXRlIHVuaXQgcG93ZXIgYWNjdW11bGF0b3IgTVNSIG9uIGNvcmUlZFxuIiwK\n" - "PiA+ICsJCQkgICAgICAgY3B1KTsKPiA+ICsJCQlyZXR1cm4gMDsKPiA+ICsJCX0KPiA+ICsKPiA+\n" - "ICsJCWlmIChjdXJyX2N1X2FjY19wb3dlcltjdV0gPCBkYXRhLT5jdV9hY2NfcG93ZXJbY3VdKSB7\n" - "Cj4gPiArCQkJamRlbHRhW2N1XSA9IGRhdGEtPm1heF9jdV9hY2NfcG93ZXIgKyBjdXJyX2N1X2Fj\n" - "Y19wb3dlcltjdV07Cj4gPiArCQkJamRlbHRhW2N1XSAtPSBkYXRhLT5jdV9hY2NfcG93ZXJbY3Vd\n" - "Owo+ID4gKwkJfSBlbHNlIHsKPiA+ICsJCQlqZGVsdGFbY3VdID0gY3Vycl9jdV9hY2NfcG93ZXJb\n" - "Y3VdIC0gZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XTsKPiA+ICsJCX0KPiA+ICsJCXRkZWx0YSA9IGN1\n" - "cnJfcHRzY1tjdV0gLSBkYXRhLT5jcHVfc3dfcHdyX3B0c2NbY3VdOwo+ID4gKwkJamRlbHRhW2N1\n" - "XSAqPSBkYXRhLT5jcHVfcHdyX3NhbXBsZV9yYXRpbyAqIDEwMDA7Cj4gPiArCQlkb19kaXYoamRl\n" - "bHRhW2N1XSwgdGRlbHRhKTsKPiA+ICsKPiA+ICsJCW11dGV4X2xvY2soJmRhdGEtPmFjY19wd3Jf\n" - "bXV0ZXgpOwo+ID4gKwkJZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XSA9IGN1cnJfY3VfYWNjX3Bvd2Vy\n" - "W2N1XTsKPiA+ICsJCWRhdGEtPmNwdV9zd19wd3JfcHRzY1tjdV0gPSBjdXJyX3B0c2NbY3VdOwo+\n" - "ID4gKwkJbXV0ZXhfdW5sb2NrKCZkYXRhLT5hY2NfcHdyX211dGV4KTsKPiA+ICsKPiA+ICsJCS8q\n" - "IHRoZSB1bml0IGlzIG1pY3JvV2F0dCAqLwo+ID4gKwkJYXZnX2FjYyArPSBqZGVsdGFbY3VdOwo+\n" - "ID4gKwl9Cj4gPiArCj4gPiArCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCAodW5zaWduZWQg\n" - "aW50KSBhdmdfYWNjKTsKPiA+ICt9Cj4gPiArc3RhdGljIERFVklDRV9BVFRSKHBvd2VyMV9hY2Ms\n" - "IFNfSVJVR08sIHNob3dfcG93ZXJfYWNjLCBOVUxMKTsKPiAKPiBJIGFtIG5vdCByZWFsbHkgYSBm\n" - "cmllbmQgb2YgaW50cm9kdWNpbmcgYSBub24tc3RhbmRhcmQgYXR0cmlidXRlLgo+IERvZXMgdGhl\n" - "IGVuZXJneSBhdHRyaWJ1dGUgbm90IHdvcmsgaGVyZSA/Cj4gCgpZb3UncmUgcmlnaHQuIE5vbi1z\n" - "dGFuZGFyZCBhdHRyaWJ1dGUgbWlnaHQgbm90IGJlIGdvb2QuIENvdWxkIHlvdQpwbGVhc2UgZ2l2\n" - "ZSBtZSBzb21lIGhpbnRzIGlmIEkgdXNlICJlbmVyZ3kiIGluc3RlYWQ/CgpUaGFua3MsClJ1aQoK\n" - "X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbG0tc2Vuc29y\n" - "cyBtYWlsaW5nIGxpc3QKbG0tc2Vuc29yc0BsbS1zZW5zb3JzLm9yZwpodHRwOi8vbGlzdHMubG0t\n" - c2Vuc29ycy5vcmcvbWFpbG1hbi9saXN0aW5mby9sbS1zZW5zb3Jz + "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" + "Thanks,\n" + Rui -1c86d7c850bcf016f655d9d4155502c2fbb3906401f15b6a45d33c0f13e02c45 +ad34e9e2499276a026da1254635b2cc1e4bec9f44c7c7c498d83e8fffdbe3bc6
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.