diff for duplicates of <55E06A99.7070800@roeck-us.net> diff --git a/a/1.txt b/N1/1.txt index 59e5cc2..c837d29 100644 --- a/a/1.txt +++ b/N1/1.txt @@ -1,79 +1,114 @@ -T24gMDgvMjgvMjAxNSAwMzo0NSBBTSwgSHVhbmcgUnVpIHdyb3RlOgo+IE9uIFRodSwgQXVnIDI3 -LCAyMDE1IGF0IDEwOjMwOjQzQU0gLTA3MDAsIEd1ZW50ZXIgUm9lY2sgd3JvdGU6Cj4+IE9uIFRo -dSwgQXVnIDI3LCAyMDE1IGF0IDA0OjA3OjQzUE0gKzA4MDAsIEh1YW5nIFJ1aSB3cm90ZToKPj4+ -IFRoaXMgcGF0Y2ggaW50cm9kdWNlcyBhbiBhbGdvcml0aG0gdGhhdCBjb21wdXRlcyB0aGUgYXZl -cmFnZSBwb3dlciBieQo+Pj4gcmVhZGluZyBhIGRlbHRhIHZhbHVlIG9mIOKAnGNvcmUgcG93ZXIg -YWNjdW11bGF0b3LigJ0gcmVnaXN0ZXIgZHVyaW5nCj4+PiBtZWFzdXJlbWVudCBpbnRlcnZhbCwg -YW5kIHRoZW4gZGl2aWRpbmcgZGVsdGEgdmFsdWUgYnkgdGhlIGxlbmd0aCBvZgo+Pj4gdGhlIHRp -bWUgaW50ZXJ2YWwuCj4+Pgo+Pj4gVXNlciBpcyBhYmxlIHRvIHVzZSBwb3dlcjFfYWNjIGVudHJ5 -IHRvIG1lYXN1cmUgdGhlIHByb2Nlc3NvciBwb3dlcgo+Pj4gY29uc3VtcHRpb24gYW5kIHBvd2Vy -MV9hY2MganVzdCBuZWVkcyB0byBiZSByZWFkIHR3aWNlIHdpdGggYW4gbmVlZGVkCj4+PiBpbnRl -cnZhbCBpbi1iZXR3ZWVuLgo+Pj4KPj4+IEEgc2ltcGxlIGV4YW1wbGU6Cj4+Pgo+Pj4gJCBjYXQg -L3N5cy9idXMvcGNpL2RldmljZXMvMDAwMFw6MDBcOjE4LjQvaHdtb24vaHdtb24wL3Bvd2VyMV9h -Y2MKPj4+ICQgc2xlZXAgMTAwMDBzCj4+PiAkIGNhdCAvc3lzL2J1cy9wY2kvZGV2aWNlcy8wMDAw -XDowMFw6MTguNC9od21vbi9od21vbjAvcG93ZXIxX2FjYwo+Pj4KPj4+IFRoZSByZXN1bHQgaXMg -Y3VycmVudCBhdmVyYWdlIHByb2Nlc3NvciBwb3dlciBjb25zdW1wdGlvbiBpbiAxMDAwMAo+Pj4g -c2Vjb25kcy4gVGhlIHVuaXQgb2YgdGhlIHJlc3VsdCBpcyB1V2F0dC4KPj4+Cj4+PiBTaWduZWQt -b2ZmLWJ5OiBIdWFuZyBSdWkgPHJheS5odWFuZ0BhbWQuY29tPgo+Pj4gLS0tCj4+PiAgIGRyaXZl -cnMvaHdtb24vZmFtMTVoX3Bvd2VyLmMgfCA2MiArKysrKysrKysrKysrKysrKysrKysrKysrKysr -KysrKysrKysrKysrKysrKwo+Pj4gICAxIGZpbGUgY2hhbmdlZCwgNjIgaW5zZXJ0aW9ucygrKQo+ -Pj4KPj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2ZhbTE1aF9wb3dlci5jIGIvZHJpdmVy -cy9od21vbi9mYW0xNWhfcG93ZXIuYwo+Pj4gaW5kZXggZDUyOWU0Yi4uM2JhYjc5NyAxMDA2NDQK -Pj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vZmFtMTVoX3Bvd2VyLmMKPj4+ICsrKyBiL2RyaXZlcnMv -aHdtb24vZmFtMTVoX3Bvd2VyLmMKPj4+IEBAIC02MCw2ICs2MCw3IEBAIHN0cnVjdCBmYW0xNWhf -cG93ZXJfZGF0YSB7Cj4+PiAgIAl1NjQgY3VfYWNjX3Bvd2VyW01BWF9DVVNdOwo+Pj4gICAJLyog -cGVyZm9ybWFuY2UgdGltZXN0YW1wIGNvdW50ZXIgKi8KPj4+ICAgCXU2NCBjcHVfc3dfcHdyX3B0 -c2NbTUFYX0NVU107Cj4+PiArCXN0cnVjdCBtdXRleCBhY2NfcHdyX211dGV4Owo+Pj4gICB9Owo+ -Pj4KPj4+ICAgc3RhdGljIHNzaXplX3Qgc2hvd19wb3dlcihzdHJ1Y3QgZGV2aWNlICpkZXYsCj4+ -PiBAQCAtMTIxLDE3ICsxMjIsNzQgQEAgc3RhdGljIERFVklDRV9BVFRSKHBvd2VyMV9jcml0LCBT -X0lSVUdPLCBzaG93X3Bvd2VyX2NyaXQsIE5VTEwpOwo+Pj4gICBzdGF0aWMgc3RydWN0IGF0dHJp -YnV0ZV9ncm91cCBmYW0xNWhfcG93ZXJfZ3JvdXA7Cj4+PiAgIF9fQVRUUklCVVRFX0dST1VQUyhm -YW0xNWhfcG93ZXIpOwo+Pj4KPj4+ICtzdGF0aWMgc3NpemVfdCBzaG93X3Bvd2VyX2FjYyhzdHJ1 -Y3QgZGV2aWNlICpkZXYsCj4+PiArCQkJICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0 -dHIsIGNoYXIgKmJ1ZikKPj4+ICt7Cj4+PiArCWludCBjcHUsIGN1LCBjdV9udW0sIGNvcmVzX3Bl -cl9jdTsKPj4+ICsJdTY0IGN1cnJfY3VfYWNjX3Bvd2VyW01BWF9DVVNdLAo+Pj4gKwkgICAgY3Vy -cl9wdHNjW01BWF9DVVNdLCBqZGVsdGFbTUFYX0NVU107Cj4+PiArCXU2NCB0ZGVsdGEsIGF2Z19h -Y2M7Cj4+PiArCXN0cnVjdCBmYW0xNWhfcG93ZXJfZGF0YSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0 -YShkZXYpOwo+Pj4gKwo+Pj4gKwljb3Jlc19wZXJfY3UgPSBhbWRfZ2V0X2NvcmVzX3Blcl9jdSgp -Owo+Pj4gKwljdV9udW0gPSBib290X2NwdV9kYXRhLng4Nl9tYXhfY29yZXMgLyBjb3Jlc19wZXJf -Y3U7Cj4+PiArCj4+PiArCWZvciAoY3B1ID0gMCwgYXZnX2FjYyA9IDA7IGNwdSA8IGN1X251bSAq -IGNvcmVzX3Blcl9jdTsgY3B1ICs9IGNvcmVzX3Blcl9jdSkgewo+Pj4gKwkJY3UgPSBjcHUgLyBj -b3Jlc19wZXJfY3U7Cj4+PiArCQlpZiAocmRtc3JsX3NhZmVfb25fY3B1KGNwdSwgTVNSX0YxNUhf -UFRTQywgJmN1cnJfcHRzY1tjdV0pKSB7Cj4+PiArCQkJcHJfZXJyKCJGYWlsZWQgdG8gcmVhZCBQ -VFNDIGNvdW50ZXIgTVNSIG9uIGNvcmUlZFxuIiwKPj4+ICsJCQkgICAgICAgY3B1KTsKPj4+ICsJ -CQlyZXR1cm4gMDsKPj4+ICsJCX0KPj4+ICsKPj4+ICsJCWlmIChyZG1zcmxfc2FmZV9vbl9jcHUo -Y3B1LCBNU1JfRjE1SF9DVV9QV1JfQUNDVU1VTEFUT1IsCj4+PiArCQkJCSAgICAgICAmY3Vycl9j -dV9hY2NfcG93ZXJbY3VdKSkgewo+Pj4gKwkJCXByX2VycigiRmFpbGVkIHRvIHJlYWQgY29tcHV0 -ZSB1bml0IHBvd2VyIGFjY3VtdWxhdG9yIE1TUiBvbiBjb3JlJWRcbiIsCj4+PiArCQkJICAgICAg -IGNwdSk7Cj4+PiArCQkJcmV0dXJuIDA7Cj4+PiArCQl9Cj4+PiArCj4+PiArCQlpZiAoY3Vycl9j -dV9hY2NfcG93ZXJbY3VdIDwgZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XSkgewo+Pj4gKwkJCWpkZWx0 -YVtjdV0gPSBkYXRhLT5tYXhfY3VfYWNjX3Bvd2VyICsgY3Vycl9jdV9hY2NfcG93ZXJbY3VdOwo+ -Pj4gKwkJCWpkZWx0YVtjdV0gLT0gZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XTsKPj4+ICsJCX0gZWxz -ZSB7Cj4+PiArCQkJamRlbHRhW2N1XSA9IGN1cnJfY3VfYWNjX3Bvd2VyW2N1XSAtIGRhdGEtPmN1 -X2FjY19wb3dlcltjdV07Cj4+PiArCQl9Cj4+PiArCQl0ZGVsdGEgPSBjdXJyX3B0c2NbY3VdIC0g -ZGF0YS0+Y3B1X3N3X3B3cl9wdHNjW2N1XTsKPj4+ICsJCWpkZWx0YVtjdV0gKj0gZGF0YS0+Y3B1 -X3B3cl9zYW1wbGVfcmF0aW8gKiAxMDAwOwo+Pj4gKwkJZG9fZGl2KGpkZWx0YVtjdV0sIHRkZWx0 -YSk7Cj4+PiArCj4+PiArCQltdXRleF9sb2NrKCZkYXRhLT5hY2NfcHdyX211dGV4KTsKPj4+ICsJ -CWRhdGEtPmN1X2FjY19wb3dlcltjdV0gPSBjdXJyX2N1X2FjY19wb3dlcltjdV07Cj4+PiArCQlk -YXRhLT5jcHVfc3dfcHdyX3B0c2NbY3VdID0gY3Vycl9wdHNjW2N1XTsKPj4+ICsJCW11dGV4X3Vu -bG9jaygmZGF0YS0+YWNjX3B3cl9tdXRleCk7Cj4+PiArCj4+PiArCQkvKiB0aGUgdW5pdCBpcyBt -aWNyb1dhdHQgKi8KPj4+ICsJCWF2Z19hY2MgKz0gamRlbHRhW2N1XTsKPj4+ICsJfQo+Pj4gKwo+ -Pj4gKwlyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwgKHVuc2lnbmVkIGludCkgYXZnX2FjYyk7 -Cj4+PiArfQo+Pj4gK3N0YXRpYyBERVZJQ0VfQVRUUihwb3dlcjFfYWNjLCBTX0lSVUdPLCBzaG93 -X3Bvd2VyX2FjYywgTlVMTCk7Cj4+Cj4+IEkgYW0gbm90IHJlYWxseSBhIGZyaWVuZCBvZiBpbnRy -b2R1Y2luZyBhIG5vbi1zdGFuZGFyZCBhdHRyaWJ1dGUuCj4+IERvZXMgdGhlIGVuZXJneSBhdHRy -aWJ1dGUgbm90IHdvcmsgaGVyZSA/Cj4+Cj4KPiBZb3UncmUgcmlnaHQuIE5vbi1zdGFuZGFyZCBh -dHRyaWJ1dGUgbWlnaHQgbm90IGJlIGdvb2QuIENvdWxkIHlvdQo+IHBsZWFzZSBnaXZlIG1lIHNv -bWUgaGludHMgaWYgSSB1c2UgImVuZXJneSIgaW5zdGVhZD8KPgoxIEpvdWxlID0gMSBXYXR0LXNl -Y29uZC4KClNvbWV0aGluZyBlbHNlLCB0aG91Z2ggLSBkaWQgeW91IG1ha2Ugc3VyZSB0aGF0IHlv -dXIgY29kZSBkb2Vzbid0IG92ZXJmbG93ID8KRXZlbiB0aG91Z2ggeW91IGNhbGN1bGF0ZSB0aGUg -YXZlcmFnZSBpbiBhbiB1NjQsIHlvdSBkaXNwbGF5IGl0IGFzIHVuc2lnbmVkLgoKMTAwdyAqIDEw -LDAwMHMgPSAxLDAwMCwwMDB3cyA9IDEsMDAwLDAwMCwwMDAsMDAwIG1pY3JvLXdhdHQtc2Vjb25k -cywgd2hpY2ggaXMKYSBiaXQgbGFyZ2UgZm9yIGFuIHVuc2lnbmVkLgoKQWxzbywgdGhlIHZhbHVl -cyBzaG91bGQgbm90IGJlIHJlc2V0IGFmdGVyIHJlYWRpbmcsIGJ1dCBhY2N1bXVsYXRlLgoKQWxz -bywgSSB0aGluayB5b3VyIGNvZGUgbWF5IGJlIHZ1bG5lcmFibGUgdG8gb3ZlcmZsb3dzIG9uIHRo -ZSBDUFUgcmVnaXN0ZXIgc2lkZS4KSG93IGxvbmcgZG9lcyBpdCB0YWtlIGJlZm9yZSB0aGUgQ1BV -IGNvdW50ZXJzIG92ZXJmbG93ID8KClRoYW5rcywKR3VlbnRlcgoKCl9fX19fX19fX19fX19fX19f -X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0Cmxt -LXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxt -YW4vbGlzdGluZm8vbG0tc2Vuc29ycw= +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. + +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 ? + +Thanks, +Guenter diff --git a/a/content_digest b/N1/content_digest index 7d0899a..58083dd 100644 --- a/a/content_digest +++ b/N1/content_digest @@ -3,8 +3,8 @@ "ref\020150827173043.GB27452@roeck-us.net\0" "ref\020150828104525.GD4191@hr-slim.amd.com\0" "From\0Guenter Roeck <linux@roeck-us.net>\0" - "Subject\0Re: [lm-sensors] [PATCH 12/15] hwmon, fam15h_power: introduce a cpu accumulated power reporting algo\0" - "Date\0Fri, 28 Aug 2015 14:05:13 +0000\0" + "Subject\0Re: [PATCH 12/15] hwmon, fam15h_power: introduce a cpu accumulated power reporting algorithm\0" + "Date\0Fri, 28 Aug 2015 07:05:13 -0700\0" "To\0Huang Rui <ray.huang@amd.com>\0" "Cc\0Borislav Petkov <bp@suse.de>" Jean Delvare <jdelvare@suse.de> @@ -28,84 +28,119 @@ " Tony Li <tony.li@amd.com>\0" "\00:1\0" "b\0" - "T24gMDgvMjgvMjAxNSAwMzo0NSBBTSwgSHVhbmcgUnVpIHdyb3RlOgo+IE9uIFRodSwgQXVnIDI3\n" - "LCAyMDE1IGF0IDEwOjMwOjQzQU0gLTA3MDAsIEd1ZW50ZXIgUm9lY2sgd3JvdGU6Cj4+IE9uIFRo\n" - "dSwgQXVnIDI3LCAyMDE1IGF0IDA0OjA3OjQzUE0gKzA4MDAsIEh1YW5nIFJ1aSB3cm90ZToKPj4+\n" - "IFRoaXMgcGF0Y2ggaW50cm9kdWNlcyBhbiBhbGdvcml0aG0gdGhhdCBjb21wdXRlcyB0aGUgYXZl\n" - "cmFnZSBwb3dlciBieQo+Pj4gcmVhZGluZyBhIGRlbHRhIHZhbHVlIG9mIOKAnGNvcmUgcG93ZXIg\n" - "YWNjdW11bGF0b3LigJ0gcmVnaXN0ZXIgZHVyaW5nCj4+PiBtZWFzdXJlbWVudCBpbnRlcnZhbCwg\n" - "YW5kIHRoZW4gZGl2aWRpbmcgZGVsdGEgdmFsdWUgYnkgdGhlIGxlbmd0aCBvZgo+Pj4gdGhlIHRp\n" - "bWUgaW50ZXJ2YWwuCj4+Pgo+Pj4gVXNlciBpcyBhYmxlIHRvIHVzZSBwb3dlcjFfYWNjIGVudHJ5\n" - "IHRvIG1lYXN1cmUgdGhlIHByb2Nlc3NvciBwb3dlcgo+Pj4gY29uc3VtcHRpb24gYW5kIHBvd2Vy\n" - "MV9hY2MganVzdCBuZWVkcyB0byBiZSByZWFkIHR3aWNlIHdpdGggYW4gbmVlZGVkCj4+PiBpbnRl\n" - "cnZhbCBpbi1iZXR3ZWVuLgo+Pj4KPj4+IEEgc2ltcGxlIGV4YW1wbGU6Cj4+Pgo+Pj4gJCBjYXQg\n" - "L3N5cy9idXMvcGNpL2RldmljZXMvMDAwMFw6MDBcOjE4LjQvaHdtb24vaHdtb24wL3Bvd2VyMV9h\n" - "Y2MKPj4+ICQgc2xlZXAgMTAwMDBzCj4+PiAkIGNhdCAvc3lzL2J1cy9wY2kvZGV2aWNlcy8wMDAw\n" - "XDowMFw6MTguNC9od21vbi9od21vbjAvcG93ZXIxX2FjYwo+Pj4KPj4+IFRoZSByZXN1bHQgaXMg\n" - "Y3VycmVudCBhdmVyYWdlIHByb2Nlc3NvciBwb3dlciBjb25zdW1wdGlvbiBpbiAxMDAwMAo+Pj4g\n" - "c2Vjb25kcy4gVGhlIHVuaXQgb2YgdGhlIHJlc3VsdCBpcyB1V2F0dC4KPj4+Cj4+PiBTaWduZWQt\n" - "b2ZmLWJ5OiBIdWFuZyBSdWkgPHJheS5odWFuZ0BhbWQuY29tPgo+Pj4gLS0tCj4+PiAgIGRyaXZl\n" - "cnMvaHdtb24vZmFtMTVoX3Bvd2VyLmMgfCA2MiArKysrKysrKysrKysrKysrKysrKysrKysrKysr\n" - "KysrKysrKysrKysrKysrKwo+Pj4gICAxIGZpbGUgY2hhbmdlZCwgNjIgaW5zZXJ0aW9ucygrKQo+\n" - "Pj4KPj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2ZhbTE1aF9wb3dlci5jIGIvZHJpdmVy\n" - "cy9od21vbi9mYW0xNWhfcG93ZXIuYwo+Pj4gaW5kZXggZDUyOWU0Yi4uM2JhYjc5NyAxMDA2NDQK\n" - "Pj4+IC0tLSBhL2RyaXZlcnMvaHdtb24vZmFtMTVoX3Bvd2VyLmMKPj4+ICsrKyBiL2RyaXZlcnMv\n" - "aHdtb24vZmFtMTVoX3Bvd2VyLmMKPj4+IEBAIC02MCw2ICs2MCw3IEBAIHN0cnVjdCBmYW0xNWhf\n" - "cG93ZXJfZGF0YSB7Cj4+PiAgIAl1NjQgY3VfYWNjX3Bvd2VyW01BWF9DVVNdOwo+Pj4gICAJLyog\n" - "cGVyZm9ybWFuY2UgdGltZXN0YW1wIGNvdW50ZXIgKi8KPj4+ICAgCXU2NCBjcHVfc3dfcHdyX3B0\n" - "c2NbTUFYX0NVU107Cj4+PiArCXN0cnVjdCBtdXRleCBhY2NfcHdyX211dGV4Owo+Pj4gICB9Owo+\n" - "Pj4KPj4+ICAgc3RhdGljIHNzaXplX3Qgc2hvd19wb3dlcihzdHJ1Y3QgZGV2aWNlICpkZXYsCj4+\n" - "PiBAQCAtMTIxLDE3ICsxMjIsNzQgQEAgc3RhdGljIERFVklDRV9BVFRSKHBvd2VyMV9jcml0LCBT\n" - "X0lSVUdPLCBzaG93X3Bvd2VyX2NyaXQsIE5VTEwpOwo+Pj4gICBzdGF0aWMgc3RydWN0IGF0dHJp\n" - "YnV0ZV9ncm91cCBmYW0xNWhfcG93ZXJfZ3JvdXA7Cj4+PiAgIF9fQVRUUklCVVRFX0dST1VQUyhm\n" - "YW0xNWhfcG93ZXIpOwo+Pj4KPj4+ICtzdGF0aWMgc3NpemVfdCBzaG93X3Bvd2VyX2FjYyhzdHJ1\n" - "Y3QgZGV2aWNlICpkZXYsCj4+PiArCQkJICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0\n" - "dHIsIGNoYXIgKmJ1ZikKPj4+ICt7Cj4+PiArCWludCBjcHUsIGN1LCBjdV9udW0sIGNvcmVzX3Bl\n" - "cl9jdTsKPj4+ICsJdTY0IGN1cnJfY3VfYWNjX3Bvd2VyW01BWF9DVVNdLAo+Pj4gKwkgICAgY3Vy\n" - "cl9wdHNjW01BWF9DVVNdLCBqZGVsdGFbTUFYX0NVU107Cj4+PiArCXU2NCB0ZGVsdGEsIGF2Z19h\n" - "Y2M7Cj4+PiArCXN0cnVjdCBmYW0xNWhfcG93ZXJfZGF0YSAqZGF0YSA9IGRldl9nZXRfZHJ2ZGF0\n" - "YShkZXYpOwo+Pj4gKwo+Pj4gKwljb3Jlc19wZXJfY3UgPSBhbWRfZ2V0X2NvcmVzX3Blcl9jdSgp\n" - "Owo+Pj4gKwljdV9udW0gPSBib290X2NwdV9kYXRhLng4Nl9tYXhfY29yZXMgLyBjb3Jlc19wZXJf\n" - "Y3U7Cj4+PiArCj4+PiArCWZvciAoY3B1ID0gMCwgYXZnX2FjYyA9IDA7IGNwdSA8IGN1X251bSAq\n" - "IGNvcmVzX3Blcl9jdTsgY3B1ICs9IGNvcmVzX3Blcl9jdSkgewo+Pj4gKwkJY3UgPSBjcHUgLyBj\n" - "b3Jlc19wZXJfY3U7Cj4+PiArCQlpZiAocmRtc3JsX3NhZmVfb25fY3B1KGNwdSwgTVNSX0YxNUhf\n" - "UFRTQywgJmN1cnJfcHRzY1tjdV0pKSB7Cj4+PiArCQkJcHJfZXJyKCJGYWlsZWQgdG8gcmVhZCBQ\n" - "VFNDIGNvdW50ZXIgTVNSIG9uIGNvcmUlZFxuIiwKPj4+ICsJCQkgICAgICAgY3B1KTsKPj4+ICsJ\n" - "CQlyZXR1cm4gMDsKPj4+ICsJCX0KPj4+ICsKPj4+ICsJCWlmIChyZG1zcmxfc2FmZV9vbl9jcHUo\n" - "Y3B1LCBNU1JfRjE1SF9DVV9QV1JfQUNDVU1VTEFUT1IsCj4+PiArCQkJCSAgICAgICAmY3Vycl9j\n" - "dV9hY2NfcG93ZXJbY3VdKSkgewo+Pj4gKwkJCXByX2VycigiRmFpbGVkIHRvIHJlYWQgY29tcHV0\n" - "ZSB1bml0IHBvd2VyIGFjY3VtdWxhdG9yIE1TUiBvbiBjb3JlJWRcbiIsCj4+PiArCQkJICAgICAg\n" - "IGNwdSk7Cj4+PiArCQkJcmV0dXJuIDA7Cj4+PiArCQl9Cj4+PiArCj4+PiArCQlpZiAoY3Vycl9j\n" - "dV9hY2NfcG93ZXJbY3VdIDwgZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XSkgewo+Pj4gKwkJCWpkZWx0\n" - "YVtjdV0gPSBkYXRhLT5tYXhfY3VfYWNjX3Bvd2VyICsgY3Vycl9jdV9hY2NfcG93ZXJbY3VdOwo+\n" - "Pj4gKwkJCWpkZWx0YVtjdV0gLT0gZGF0YS0+Y3VfYWNjX3Bvd2VyW2N1XTsKPj4+ICsJCX0gZWxz\n" - "ZSB7Cj4+PiArCQkJamRlbHRhW2N1XSA9IGN1cnJfY3VfYWNjX3Bvd2VyW2N1XSAtIGRhdGEtPmN1\n" - "X2FjY19wb3dlcltjdV07Cj4+PiArCQl9Cj4+PiArCQl0ZGVsdGEgPSBjdXJyX3B0c2NbY3VdIC0g\n" - "ZGF0YS0+Y3B1X3N3X3B3cl9wdHNjW2N1XTsKPj4+ICsJCWpkZWx0YVtjdV0gKj0gZGF0YS0+Y3B1\n" - "X3B3cl9zYW1wbGVfcmF0aW8gKiAxMDAwOwo+Pj4gKwkJZG9fZGl2KGpkZWx0YVtjdV0sIHRkZWx0\n" - "YSk7Cj4+PiArCj4+PiArCQltdXRleF9sb2NrKCZkYXRhLT5hY2NfcHdyX211dGV4KTsKPj4+ICsJ\n" - "CWRhdGEtPmN1X2FjY19wb3dlcltjdV0gPSBjdXJyX2N1X2FjY19wb3dlcltjdV07Cj4+PiArCQlk\n" - "YXRhLT5jcHVfc3dfcHdyX3B0c2NbY3VdID0gY3Vycl9wdHNjW2N1XTsKPj4+ICsJCW11dGV4X3Vu\n" - "bG9jaygmZGF0YS0+YWNjX3B3cl9tdXRleCk7Cj4+PiArCj4+PiArCQkvKiB0aGUgdW5pdCBpcyBt\n" - "aWNyb1dhdHQgKi8KPj4+ICsJCWF2Z19hY2MgKz0gamRlbHRhW2N1XTsKPj4+ICsJfQo+Pj4gKwo+\n" - "Pj4gKwlyZXR1cm4gc3ByaW50ZihidWYsICIldVxuIiwgKHVuc2lnbmVkIGludCkgYXZnX2FjYyk7\n" - "Cj4+PiArfQo+Pj4gK3N0YXRpYyBERVZJQ0VfQVRUUihwb3dlcjFfYWNjLCBTX0lSVUdPLCBzaG93\n" - "X3Bvd2VyX2FjYywgTlVMTCk7Cj4+Cj4+IEkgYW0gbm90IHJlYWxseSBhIGZyaWVuZCBvZiBpbnRy\n" - "b2R1Y2luZyBhIG5vbi1zdGFuZGFyZCBhdHRyaWJ1dGUuCj4+IERvZXMgdGhlIGVuZXJneSBhdHRy\n" - "aWJ1dGUgbm90IHdvcmsgaGVyZSA/Cj4+Cj4KPiBZb3UncmUgcmlnaHQuIE5vbi1zdGFuZGFyZCBh\n" - "dHRyaWJ1dGUgbWlnaHQgbm90IGJlIGdvb2QuIENvdWxkIHlvdQo+IHBsZWFzZSBnaXZlIG1lIHNv\n" - "bWUgaGludHMgaWYgSSB1c2UgImVuZXJneSIgaW5zdGVhZD8KPgoxIEpvdWxlID0gMSBXYXR0LXNl\n" - "Y29uZC4KClNvbWV0aGluZyBlbHNlLCB0aG91Z2ggLSBkaWQgeW91IG1ha2Ugc3VyZSB0aGF0IHlv\n" - "dXIgY29kZSBkb2Vzbid0IG92ZXJmbG93ID8KRXZlbiB0aG91Z2ggeW91IGNhbGN1bGF0ZSB0aGUg\n" - "YXZlcmFnZSBpbiBhbiB1NjQsIHlvdSBkaXNwbGF5IGl0IGFzIHVuc2lnbmVkLgoKMTAwdyAqIDEw\n" - "LDAwMHMgPSAxLDAwMCwwMDB3cyA9IDEsMDAwLDAwMCwwMDAsMDAwIG1pY3JvLXdhdHQtc2Vjb25k\n" - "cywgd2hpY2ggaXMKYSBiaXQgbGFyZ2UgZm9yIGFuIHVuc2lnbmVkLgoKQWxzbywgdGhlIHZhbHVl\n" - "cyBzaG91bGQgbm90IGJlIHJlc2V0IGFmdGVyIHJlYWRpbmcsIGJ1dCBhY2N1bXVsYXRlLgoKQWxz\n" - "bywgSSB0aGluayB5b3VyIGNvZGUgbWF5IGJlIHZ1bG5lcmFibGUgdG8gb3ZlcmZsb3dzIG9uIHRo\n" - "ZSBDUFUgcmVnaXN0ZXIgc2lkZS4KSG93IGxvbmcgZG9lcyBpdCB0YWtlIGJlZm9yZSB0aGUgQ1BV\n" - "IGNvdW50ZXJzIG92ZXJmbG93ID8KClRoYW5rcywKR3VlbnRlcgoKCl9fX19fX19fX19fX19fX19f\n" - "X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxtLXNlbnNvcnMgbWFpbGluZyBsaXN0Cmxt\n" - "LXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKaHR0cDovL2xpc3RzLmxtLXNlbnNvcnMub3JnL21haWxt\n" - YW4vbGlzdGluZm8vbG0tc2Vuc29ycw= + "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" + "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" + "Thanks,\n" + Guenter -cf70f67da39d95a6d93d58dd1ae42168376d01459fed103700d4b3bb05fbb603 +11c9622f0ca2448355fd8db39f41a2741de5e829ae966e6c9166ac8b282e9c10
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.