| /* |
| * Copyright (C) 2021 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "pixelstats: PowerMitigationStats" |
| |
| #include <aidl/android/frameworks/stats/IStats.h> |
| #include <android-base/file.h> |
| #include <android-base/parseint.h> |
| #include <android-base/properties.h> |
| #include <android-base/stringprintf.h> |
| #include <android-base/strings.h> |
| #include <android/binder_manager.h> |
| #include <hardware/google/pixel/pixelstats/pixelatoms.pb.h> |
| #include <pixelstats/MitigationStatsReporter.h> |
| #include <utils/Log.h> |
| |
| namespace android { |
| namespace hardware { |
| namespace google { |
| namespace pixel { |
| |
| using aidl::android::frameworks::stats::IStats; |
| using aidl::android::frameworks::stats::VendorAtom; |
| using aidl::android::frameworks::stats::VendorAtomValue; |
| using android::base::ReadFileToString; |
| using android::hardware::google::pixel::PixelAtoms::PowerMitigationStats; |
| |
| MitigationStatsReporter::MitigationStatsReporter() {} |
| |
| bool MitigationStatsReporter::ReadFileToInt(const std::string &path, int *val) { |
| std::string file_contents; |
| |
| if (!ReadFileToString(path.c_str(), &file_contents)) { |
| ALOGI("Unable to read %s - %s", path.c_str(), strerror(errno)); |
| return false; |
| } else { |
| file_contents = android::base::Trim(file_contents); |
| if (!android::base::ParseInt(file_contents, val)) { |
| ALOGI("Unable to convert %s to int - %s", path.c_str(), strerror(errno)); |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| void MitigationStatsReporter::logMitigationStatsPerHour(const std::shared_ptr<IStats> &stats_client, |
| const std::string &path) { |
| struct MitigationCount last_count = {}; |
| struct MitigationCap last_cap = {}; |
| |
| if (!logMitigationCount(path, &last_count)) |
| return; |
| logMitigationCap(path, &last_cap); |
| |
| VendorAtomValue tmp; |
| std::vector<VendorAtomValue> values(24); |
| tmp.set<VendorAtomValue::intValue>(last_count.batoilo_count - prev_count.batoilo_count); |
| values[PowerMitigationStats::kBatoiloCountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.vdroop1_count - prev_count.vdroop1_count); |
| values[PowerMitigationStats::kVdroop1CountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.vdroop2_count - prev_count.vdroop2_count); |
| values[PowerMitigationStats::kVdroop2CountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.smpl_warn_count - prev_count.smpl_warn_count); |
| values[PowerMitigationStats::kSmplWarnCountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.ocp_cpu1_count - prev_count.ocp_cpu1_count); |
| values[PowerMitigationStats::kOcpCpu1CountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.ocp_cpu2_count - prev_count.ocp_cpu2_count); |
| values[PowerMitigationStats::kOcpCpu2CountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.ocp_gpu_count - prev_count.ocp_gpu_count); |
| values[PowerMitigationStats::kOcpGpuCountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.ocp_tpu_count - prev_count.ocp_tpu_count); |
| values[PowerMitigationStats::kOcpTpuCountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.soft_ocp_cpu1_count - |
| prev_count.soft_ocp_cpu1_count); |
| values[PowerMitigationStats::kSoftOcpCpu1CountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.soft_ocp_cpu2_count - |
| prev_count.soft_ocp_cpu2_count); |
| values[PowerMitigationStats::kSoftOcpCpu2CountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.soft_ocp_gpu_count - |
| prev_count.soft_ocp_gpu_count); |
| values[PowerMitigationStats::kSoftOcpGpuCountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_count.soft_ocp_tpu_count - |
| prev_count.soft_ocp_tpu_count); |
| values[PowerMitigationStats::kSoftOcpTpuCountFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.batoilo_cap); |
| values[PowerMitigationStats::kBatoiloCapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.vdroop1_cap); |
| values[PowerMitigationStats::kVdroop1CapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.vdroop2_cap); |
| values[PowerMitigationStats::kVdroop2CapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.smpl_warn_cap); |
| values[PowerMitigationStats::kSmplWarnCapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.ocp_cpu1_cap); |
| values[PowerMitigationStats::kOcpCpu1CapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.ocp_cpu2_cap); |
| values[PowerMitigationStats::kOcpCpu2CapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.ocp_gpu_cap); |
| values[PowerMitigationStats::kOcpGpuCapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.ocp_tpu_cap); |
| values[PowerMitigationStats::kOcpTpuCapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.soft_ocp_cpu1_cap); |
| values[PowerMitigationStats::kSoftOcpCpu1CapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.soft_ocp_cpu2_cap); |
| values[PowerMitigationStats::kSoftOcpCpu2CapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.soft_ocp_gpu_cap); |
| values[PowerMitigationStats::kSoftOcpGpuCapFieldNumber - kVendorAtomOffset] = tmp; |
| tmp.set<VendorAtomValue::intValue>(last_cap.soft_ocp_tpu_cap); |
| values[PowerMitigationStats::kSoftOcpTpuCapFieldNumber - kVendorAtomOffset] = tmp; |
| |
| prev_count = last_count; |
| // Send vendor atom to IStats HAL |
| VendorAtom event = {.reverseDomainName = "", |
| .atomId = PixelAtoms::Atom::kMitigationStats, |
| .values = std::move(values)}; |
| const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(event); |
| if (!ret.isOk()) |
| ALOGE("Unable to report to Stats service"); |
| } |
| |
| void MitigationStatsReporter::logMitigationCap(const std::string kMitigationDir, |
| struct MitigationCap *last_cap) { |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/batoilo_cap", |
| &(last_cap->batoilo_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/ocp_cpu1_cap", |
| &(last_cap->ocp_cpu1_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/ocp_cpu2_cap", |
| &(last_cap->ocp_cpu2_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/ocp_gpu_cap", |
| &(last_cap->ocp_gpu_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/ocp_tpu_cap", |
| &(last_cap->ocp_tpu_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/smpl_warn_cap", |
| &(last_cap->smpl_warn_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/soft_ocp_cpu1_cap", |
| &(last_cap->soft_ocp_cpu1_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/soft_ocp_cpu2_cap", |
| &(last_cap->soft_ocp_cpu2_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/soft_ocp_gpu_cap", |
| &(last_cap->soft_ocp_gpu_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/soft_ocp_tpu_cap", |
| &(last_cap->soft_ocp_tpu_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/vdroop1_cap", |
| &(last_cap->vdroop1_cap)); |
| ReadFileToInt(kMitigationDir + "/last_triggered_capacity/vdroop2_cap", |
| &(last_cap->vdroop2_cap)); |
| } |
| |
| bool MitigationStatsReporter::logMitigationCount(const std::string kMitigationDir, |
| struct MitigationCount *last_count) { |
| bool send_stats = false; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/batoilo_count", |
| &(last_count->batoilo_count))) |
| return false; |
| send_stats |= (last_count->batoilo_count - prev_count.batoilo_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/ocp_cpu1_count", |
| &(last_count->ocp_cpu1_count))) |
| return false; |
| send_stats |= (last_count->ocp_cpu1_count - prev_count.ocp_cpu1_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/ocp_cpu2_count", |
| &(last_count->ocp_cpu2_count))) |
| return false; |
| send_stats |= (last_count->ocp_cpu2_count - prev_count.ocp_cpu2_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/ocp_gpu_count", |
| &(last_count->ocp_gpu_count))) |
| return false; |
| send_stats |= (last_count->ocp_gpu_count - prev_count.ocp_gpu_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/ocp_tpu_count", |
| &(last_count->ocp_tpu_count))) |
| return false; |
| send_stats |= (last_count->ocp_tpu_count - prev_count.ocp_tpu_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/smpl_warn_count", |
| &(last_count->smpl_warn_count))) |
| return false; |
| send_stats |= (last_count->smpl_warn_count - prev_count.smpl_warn_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/soft_ocp_cpu1_count", |
| &(last_count->soft_ocp_cpu1_count))) |
| return false; |
| send_stats |= (last_count->soft_ocp_cpu1_count - prev_count.soft_ocp_cpu1_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/soft_ocp_cpu2_count", |
| &(last_count->soft_ocp_cpu2_count))) |
| return false; |
| send_stats |= (last_count->soft_ocp_cpu2_count - prev_count.soft_ocp_cpu2_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/soft_ocp_gpu_count", |
| &(last_count->soft_ocp_gpu_count))) |
| return false; |
| send_stats |= (last_count->soft_ocp_gpu_count - prev_count.soft_ocp_gpu_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/soft_ocp_tpu_count", |
| &(last_count->soft_ocp_tpu_count))) |
| return false; |
| send_stats |= (last_count->soft_ocp_tpu_count - prev_count.soft_ocp_tpu_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/vdroop1_count", |
| &(last_count->vdroop1_count))) |
| return false; |
| send_stats |= (last_count->vdroop1_count - prev_count.vdroop1_count) > 0; |
| if (!ReadFileToInt(kMitigationDir + "/last_triggered_count/vdroop2_count", |
| &(last_count->vdroop2_count))) |
| return false; |
| send_stats |= (last_count->vdroop2_count - prev_count.vdroop2_count) > 0; |
| return send_stats; |
| } |
| |
| } // namespace pixel |
| } // namespace google |
| } // namespace hardware |
| } // namespace android |
